name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Nat.Gcd.0.Nat.gcd_pos_iff._simp_1_2 | Init.Data.Nat.Gcd | ∀ {p q : Prop} [d₁ : Decidable p] [d₂ : Decidable q], (¬(p ∧ q)) = (¬p ∨ ¬q) | null | false |
Algebra.Generators.Hom.mk.inj | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S}
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} {inst_3 : CommRing R'}
{inst_4 : CommRing S'} {inst_5 : Algebra R' S'} {P' : Algebra.Generators R' S' ι'} {inst_6 : Algebra S S'}
... | null | true |
Lean.PrettyPrinter.Parenthesizer.categoryParser.parenthesizer.match_1 | Lean.PrettyPrinter.Parenthesizer | (motive : List Lean.PrettyPrinter.CategoryParenthesizer → Sort u_1) →
(x : List Lean.PrettyPrinter.CategoryParenthesizer) →
((p : Lean.PrettyPrinter.CategoryParenthesizer) →
(tail : List Lean.PrettyPrinter.CategoryParenthesizer) → motive (p :: tail)) →
((x : List Lean.PrettyPrinter.CategoryParenthes... | null | false |
Function.OfArity.curry_two_eq_curry | Mathlib.Data.Fin.Tuple.Curry | ∀ {α β : Type u} (f : (Fin 2 → α) → β), Function.OfArity.curry f = Function.curry (f ∘ ⇑(finTwoArrowEquiv α).symm) | null | true |
Lean.Meta.Grind.propagateDIte | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator | Propagates `dite` upwards | true |
CategoryTheory.Bicategory.whiskerLeft_hom_inv_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ≅ h) (k : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g k) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory... | null | true |
Turing.TM2.stepAux.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : DecidableEq K] (x : σ)
(x_1 : (k : K) → List (Γ k)) (k : K) (f : σ → Γ k) (q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2.stepAux (Turing.TM2.Stmt.push k f q) x x_1 = Turing.TM2.stepAux q x (Function.update x_1 k (f x :: x_1 k)) | null | true |
IsTensorProduct.equiv_apply | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} [inst : CommSemiring R] {M₁ : Type u_2} {M₂ : Type u_3} {M : Type u_4} [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R M] {f : M₁ →ₗ[R] M₂ →ₗ[R] M} (h : IsTensorProduct f) (x : TensorProduct R M₁ M₂)... | null | true |
Lean.Elab.Term.Do.ToTerm.Context.mk.injEq | Lean.Elab.Do.Legacy | ∀ (m returnType : Lean.Syntax) (uvars : Array Lean.Elab.Term.Do.Var) (kind : Lean.Elab.Term.Do.ToTerm.Kind)
(m_1 returnType_1 : Lean.Syntax) (uvars_1 : Array Lean.Elab.Term.Do.Var) (kind_1 : Lean.Elab.Term.Do.ToTerm.Kind),
({ m := m, returnType := returnType, uvars := uvars, kind := kind } =
{ m := m_1, retur... | null | true |
_private.Mathlib.InformationTheory.KullbackLeibler.Basic.0.InformationTheory.toReal_klDiv_smul_right._simp_1_4 | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
addMonoidHomOfMemClosureRangeCoe_apply | Mathlib.Topology.Algebra.Monoid | ∀ {M₁ : Type u_6} {M₂ : Type u_7} [inst : TopologicalSpace M₂] [inst_1 : T2Space M₂] [inst_2 : AddZeroClass M₁]
[inst_3 : AddZeroClass M₂] [inst_4 : ContinuousAdd M₂] {F : Type u_8} [inst_5 : FunLike F M₁ M₂]
[inst_6 : AddMonoidHomClass F M₁ M₂] (f : M₁ → M₂) (hf : f ∈ closure (Set.range fun f x => f x)),
⇑(addMo... | null | true |
SemiNormedGrp.instCoeSortType | Mathlib.Analysis.Normed.Group.SemiNormedGrp | CoeSort SemiNormedGrp (Type u_1) | null | true |
ExpChar.zero | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R], ExpChar R 1 | null | true |
UInt8.toUInt16_div | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), (a / b).toUInt16 = a.toUInt16 / b.toUInt16 | null | true |
Rat.instSemilatticeInf | Mathlib.Algebra.Order.Ring.Unbundled.Rat | SemilatticeInf ℚ | null | true |
CategoryTheory.Subfunctor.range_eq_top | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (p : F' ⟶ F)
[CategoryTheory.Epi p], CategoryTheory.Subfunctor.range p = ⊤ | null | true |
Associates.instCommMonoidWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] (a : M), 0 * Associates.mk a = 0 | null | false |
Mathlib.Meta.NormNum.isInt_add | Mathlib.Tactic.NormNum.Basic | ∀ {α : Type u_1} [inst : Ring α] {f : α → α → α} {a b : α} {a' b' c : ℤ},
f = HAdd.hAdd →
Mathlib.Meta.NormNum.IsInt a a' →
Mathlib.Meta.NormNum.IsInt b b' → a'.add b' = c → Mathlib.Meta.NormNum.IsInt (f a b) c | null | true |
ISize.minValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : ISize), ISize.minValue.toInt ≤ x.toInt | null | true |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.comp_injOn.match_1_1 | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {f : ι → Set X} (x : X)
(motive : (∃ t ∈ nhds x, {i | (f i ∩ t).Nonempty}.Finite) → Prop)
(x_1 : ∃ t ∈ nhds x, {i | (f i ∩ t).Nonempty}.Finite),
(∀ (t : Set X) (htx : t ∈ nhds x) (htf : {i | (f i ∩ t).Nonempty}.Finite), motive ⋯) → motive x_1 | null | false |
ContinuousLinearMap.isPositive_self_comp_adjoint | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : CompleteSpace E] [inst_6 : CompleteSpace F] (S : E →L[𝕜] F),
(S ∘SL ContinuousLinearMap.adjoint S).IsPos... | null | true |
_private.Mathlib.Order.Cover.0.Pi.covBy_iff_exists_left_eq._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
ZNum.pred | Mathlib.Data.Num.Basic | ZNum → ZNum | The predecessor of a `ZNum`. | true |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit!_list_of_not_mem_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : Inhabited α],
t.WF →
∀ {l : List α} {k k' : α},
compare k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬compare a b = Ordering.eq) l →
k ∈ l → (↑(Std.DTreeMap.Inte... | null | true |
MeasureTheory.Measure.addHaarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsAddLeftInvariant], Meas... | null | true |
Aesop.Frontend.AttrConfig.noConfusionType | Aesop.Frontend.Attribute | Sort u → Aesop.Frontend.AttrConfig → Aesop.Frontend.AttrConfig → Sort u | null | false |
Std.TreeSet.le_max!_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
k ∈ t → (cmp k t.max!).isLE = true | null | true |
Composition.ones | Mathlib.Combinatorics.Enumerative.Composition | (n : ℕ) → Composition n | The composition made of blocks all of size `1`. | true |
TopologicalSpace.Closeds.complOrderIso | Mathlib.Topology.Sets.Closeds | (α : Type u_2) → [inst : TopologicalSpace α] → TopologicalSpace.Closeds α ≃o (TopologicalSpace.Opens α)ᵒᵈ | `TopologicalSpace.Closeds.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Opens α`. | true |
AddSubmonoid.gciMapComap.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective ⇑f),
AddSubmonoid.gciMapComap hf = ⋯.toGaloisCoinsertion ⋯ | null | true |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp.match_1.eq_6 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → PosNum → Sort u_1) (a b : PosNum) (h_1 : Unit → motive PosNum.one PosNum.one)
(h_2 : (x : PosNum) → motive x PosNum.one) (h_3 : (x : PosNum) → motive PosNum.one x)
(h_4 : (a b : PosNum) → motive a.bit0 b.bit0) (h_5 : (a b : PosNum) → motive a.bit0 b.bit1)
(h_6 : (a b : PosNum) → motive a.bit1... | null | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_right_p | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {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 : ι} (f : i ⟶ j) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObjec... | null | true |
Std.ExtHashSet.ext_mem | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] {m₁ m₂ : Std.ExtHashSet α},
(∀ (k : α), k ∈ m₁ ↔ k ∈ m₂) → m₁ = m₂ | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.EMatchTheoremKind.toAttributeCore.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u_1) →
(kind : Lean.Meta.Grind.EMatchTheoremKind) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs true)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs false)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs true)) →
... | null | false |
CategoryTheory.Coreflective.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{L : CategoryTheory.Functor C D} →
{P : Sort u} →
{toFull : L.Full} →
{toFaithful : L.Faithful} →
{R : CategoryTheory.Func... | null | false |
Sigma.forall | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop},
(∀ (x : (a : α) × β a), p x) ↔ ∀ (a : α) (b : β a), p ⟨a, b⟩ | null | true |
GenLoop.fromLoop_coe | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N)
(p : LoopSpace (↑(GenLoop { j // j ≠ i } X x)) GenLoop.const),
↑(GenLoop.fromLoop i p) =
({ toFun := Subtype.val, continuous_toFun := ⋯ }.comp p.toContinuousMap).uncurry.comp ↑(Cube.splitAt i) | null | true |
Lean._aux_Init_Meta___macroRules_Lean_Parser_Syntax_addPrio_1 | Init.Meta | Lean.Macro | null | false |
Set.ne_univ_iff_exists_notMem | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} (s : Set α), s ≠ Set.univ ↔ ∃ a, a ∉ s | null | true |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.add_lt_aleph0_iff.match_1_1 | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}} (motive : a < Cardinal.aleph0 ∧ b < Cardinal.aleph0 → Prop)
(x : a < Cardinal.aleph0 ∧ b < Cardinal.aleph0),
(∀ (h1 : a < Cardinal.aleph0) (h2 : b < Cardinal.aleph0), motive ⋯) → motive x | null | false |
Algebra.PreSubmersivePresentation.baseChange | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(T : Type u_1) →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
Algebra.PreSu... | If `P` is a pre-submersive presentation of `S` over `R` and `T` is an `R`-algebra, we
obtain a natural pre-submersive presentation of `T ⊗[R] S` over `T`. | true |
SchwartzMap.instIsUniformAddGroup | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F], IsUniformAddGroup (SchwartzMap E F) | null | true |
RBTree.RBNode.IsCut.gt_trans | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {x y : α} [RBTree.RBNode.IsCut cmp cut]
[Std.TransCmp cmp], cmp x y = Ordering.lt → cut y = Ordering.gt → cut x = Ordering.gt | null | true |
GrpCat.hasLimitsOfShape | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] [Small.{u, v} J],
CategoryTheory.Limits.HasLimitsOfShape J GrpCat | If `J` is `u`-small, `GrpCat.{u}` has limits of shape `J`. | true |
ChainComplex.truncateAugment._proof_3 | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : ChainComplex V ℕ) {X : V} (f : C.X 0 ⟶ X) (w : CategoryTheory.CategoryStruct.comp (C.d 1 0) f = 0) (i j : ℕ),
(ComplexShape.down ℕ).Rel i j →
CategoryTheory.CategoryStruct.comp (CategoryTheory... | null | false |
ShrinkingLemma.PartialRefinement.noConfusionType | Mathlib.Topology.ShrinkingLemma | Sort u →
{ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
ShrinkingLemma.PartialRefinement u s p →
{ι' : Type u_1} →
{X' : Type u_2} →
[inst' ... | null | false |
Lean.Elab.Tactic.Do.ProofMode.ensureMGoal | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Elab.Tactic.TacticM (Lean.MVarId × Lean.Elab.Tactic.Do.ProofMode.MGoal) | null | true |
ContinuousLinearMap.toBilinForm_inj | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_2} {E : Type u_5} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] (L₁ L₂ : E →L[𝕜] E →L[𝕜] 𝕜), L₁.toBilinForm = L₂.toBilinForm ↔ L₁ = L₂ | null | true |
CategoryTheory.CostructuredArrow.faithful_map₂ | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V... | null | true |
CategoryTheory.Pretriangulated.Triangle.epi₁ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} 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] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pr... | null | true |
NumberField.CMExtension.algebraMap_equivMaximalRealSubfield_symm_apply | Mathlib.NumberTheory.NumberField.CMField | ∀ (F : Type u_1) (K : Type u_2) [inst : Field F] [inst_1 : NumberField.IsTotallyReal F] [inst_2 : Field K]
[inst_3 : CharZero K] [inst_4 : Algebra.IsIntegral ℚ K] [inst_5 : NumberField.IsTotallyComplex K]
[inst_6 : Algebra F K] [inst_7 : Algebra.IsQuadraticExtension F K] (x : ↥(NumberField.maximalRealSubfield K)),
... | null | true |
IsLocalization.Away.awayToAwayRight_eq | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {P : Type u_3}
[inst_3 : CommSemiring P] (x : R) [inst_4 : IsLocalization.Away x S] (y : R) [inst_5 : Algebra R P]
[inst_6 : IsLocalization.Away (x * y) P] (a : R),
(IsLocalization.Away.awayToAwayRight x y) ((... | null | true |
IsPrimitiveRoot.ne_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → 1 < k → ζ ≠ 1 | null | true |
Ordinal.IsFundamentalSequence.strict_mono | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {a o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{u}},
a.IsFundamentalSequence o f → ∀ {i j : Ordinal.{u}} (hi : i < o) (hj : j < o), i < j → f i hi < f j hj | null | true |
WeierstrassCurve.Jacobian.baseChange_addXYZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W' : WeierstrassCurve.Jacobian R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsS... | null | true |
Lean.Elab.Term.registerMVarErrorInfo | Lean.Elab.Term.TermElabM | Lean.Elab.Term.MVarErrorInfo → Lean.Elab.TermElabM Unit | null | true |
Cardinal.cantorFunctionAux_true | Mathlib.Analysis.Real.Cardinality | ∀ {c : ℝ} {f : ℕ → Bool} {n : ℕ}, f n = true → Cardinal.cantorFunctionAux c f n = c ^ n | null | true |
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.disjoint_single_single._simp_1_3 | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | null | false |
ZetaAsymptotics.termSum | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ℝ → ℕ → ℝ | Sum of finitely many `term`s. | true |
Int.mul_le_mul_left._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, 0 < a → (a * b ≤ a * c) = (b ≤ c) | null | false |
EReal.Tendsto.const_mul | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {f : Filter α} {m : α → EReal} {a b : EReal},
Filter.Tendsto m f (nhds b) → a ≠ ⊥ ∨ b ≠ 0 → a ≠ ⊤ ∨ b ≠ 0 → Filter.Tendsto (fun b => a * m b) f (nhds (a * b)) | null | true |
Lean.Elab.Command.AssertExists._sizeOf_1 | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → ℕ | null | false |
Metric.edistLtTopSetoid._proof_2 | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {x y : α}, edist x y < ⊤ → edist y x < ⊤ | null | false |
lp.evalCLM._proof_2 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ (𝕜 : Type u_3) {α : Type u_2} (E : α → Type u_1) [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedRing 𝕜]
[inst_2 : (i : α) → Module 𝕜 (E i)] [inst_3 : ∀ (i : α), IsBoundedSMul 𝕜 (E i)] (p : ENNReal) [inst_4 : Fact (1 ≤ p)]
(i : α) (x : ↥(lp E p)), ‖(lp.evalₗ E p i) x‖ ≤ 1 * ‖x‖ | null | false |
List.mem_pi_toList | Mathlib.Data.FinEnum | ∀ {α : Type u_1} [inst : FinEnum α] {β : α → Type u_2} [inst_1 : (a : α) → FinEnum (β a)] (xs : List α)
(f : (a : α) → a ∈ xs → β a), f ∈ xs.pi fun x => FinEnum.toList (β x) | null | true |
IsAlgClosed.degree_eq_one_of_irreducible | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (k : Type u) [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, Irreducible p → p.degree = 1 | If `k` is algebraically closed, then every irreducible polynomial over `k` is linear.
| true |
_private.Mathlib.Order.Antisymmetrization.0.wellFoundedLT_antisymmetrization_iff._simp_1_1 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u) (r : α → α → Prop), IsWellFounded α r = WellFounded r | null | false |
CategoryTheory.Discrete.monoidalFunctorMonoidal._proof_10 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] (F : M →* N) (X : CategoryTheory.Discrete M),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor ((CategoryTheory.Discrete.monoidalFunctor F).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerL... | null | false |
Applicative.seqRight._default | Init.Prelude | {f : Type u → Type v} →
({α β : Type u} → (α → β) → f α → f β) →
({α β : Type u} → α → f β → f α) →
({α β : Type u} → f (α → β) → (Unit → f α) → f β) → {α β : Type u} → f α → (Unit → f β) → f β | null | false |
groupCohomology.exists_mul_galRestrict_of_norm_eq_one | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K L : Type} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L]
[inst_4 : IsGalois K L] [IsCyclic Gal(L/K)] {g : Gal(L/K)} {A : Type u_1} {B : Type u_2} [inst_6 : CommRing A]
[inst_7 : CommRing B] [inst_8 : Algebra A B] [inst_9 : Algebra A L] [inst_10 : Algebra A K] [inst_11 : Alge... | The integral version of the classical formulation of Hilbert's theorem 90: in the `ABKL`
setting, suppose that `L/K` is a finite Galois extension such that the Galois group is cyclic
generated by `g` and let `η : B` be an element of norm `1` (when viewed as an element of `L`).
Then there exists `ε : B` such that `ε ≠ 0... | true |
_private.Mathlib.Topology.Bornology.BoundedOperation.0.isBounded_pow._simp_1_2 | Mathlib.Topology.Bornology.BoundedOperation | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
Multiset.le_union_left | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ≤ s ∪ t | null | true |
SzemerediRegularity.coe_stepBound | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | ∀ {α : Type u_1} [inst : Semiring α] (n : ℕ), ↑(SzemerediRegularity.stepBound n) = ↑n * 4 ^ n | null | true |
Nat.Primrec.below.comp | Mathlib.Computability.Primrec.Basic | ∀ {motive : (a : ℕ → ℕ) → Nat.Primrec a → Prop} {f g : ℕ → ℕ} (a : Nat.Primrec f) (a_1 : Nat.Primrec g),
Nat.Primrec.below a → motive f a → Nat.Primrec.below a_1 → motive g a_1 → Nat.Primrec.below ⋯ | null | true |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.getCandidates | Mathlib.Tactic.ClickSuggestions.TryPremises | Lean.Expr →
Lean.Expr →
Array Mathlib.Tactic.ClickSuggestions.GrwPos →
Mathlib.Tactic.ClickSuggestions.RwKind →
Option Lean.Expr →
Mathlib.Tactic.ClickSuggestions.PreDiscrTrees →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM (Array Mathlib.Tactic.ClickSuggestions.Candidates... | Get the candidate theorems from `pres`.
Used for current file declarations and local hypotheses | true |
HomologicalComplex.Hom.ext_iff | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} {inst : CategoryTheory.Category.{v, u} V}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms V} {c : ComplexShape ι} {A B : HomologicalComplex V c}
{x y : A.Hom B}, x = y ↔ x.f = y.f | null | true |
BooleanSubalgebra.sSup_mem | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : CompleteBooleanAlgebra α] {L : BooleanSubalgebra α} {s : Set α}, s.Finite → s ⊆ ↑L → sSup s ∈ L | null | true |
_private.Init.Data.UInt.Lemmas.0.USize.lt_of_lt_of_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Concept.strictAnti_intent | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop}, StrictAnti Concept.intent | null | true |
RestrictedProduct.instNSMul.eq_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → AddMonoid (R i)] [inst_2 : ∀ (i : ι), AddSubmonoidClass (S i) (R i)],
RestrictedProduct.instNSMul R = { smul := fun x x_1 => ⟨fun i => x • x_1 i, ⋯⟩ } | null | true |
CategoryTheory.Pretopology.toGrothendieck | Mathlib.CategoryTheory.Sites.Pretopology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
CategoryTheory.Pretopology C → CategoryTheory.GrothendieckTopology C | A pretopology `K` can be completed to a Grothendieck topology `J` by declaring a sieve to be
`J`-covering if it contains a family in `K`.
See also [MM92] Chapter III, Section 2, Equation (2).
| true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context._sizeOf_1 | Lean.Meta.IndPredBelow | Lean.Meta.IndPredBelow.Context✝ → ℕ | null | false |
Lean.Omega.Fin.lt_or_gt_of_ne | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, i ≠ j → i < j ∨ i > j | null | true |
AddSubgroup.inf_addSubgroupOf_left | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] (H K : AddSubgroup G), (K ⊓ H).addSubgroupOf K = H.addSubgroupOf K | null | true |
Field.lift_rank_mul_lift_sepDegree_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsSeparable F E],
Cardinal.lift.{w, v} (Module.rank F E) * Cardinal.lift.{v, w} (Field.sepDegree E K) =
Cardinal.lif... | If `K / E / F` is a field extension tower, such that `E / F` is separable,
then $[E:F] [K:E]_s = [K:F]_s$.
It is a special case of `Field.lift_sepDegree_mul_lift_sepDegree_of_isAlgebraic`, and is an
intermediate result used to prove it. | true |
_private.Init.Data.Int.LemmasAux.0.Int.toNat_sub_of_le._proof_1_1 | Init.Data.Int.LemmasAux | ∀ {a b : ℤ}, b ≤ a → ¬↑(a - b).toNat = a - b → False | null | false |
ULift.nonUnitalNonAssocSemiring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : NonUnitalNonAssocSemiring R] (a : ULift.{u_1, u_2} R), 0 * a = 0 | null | false |
Matrix.blockDiagonalAddMonoidHom | Mathlib.Data.Matrix.Block | (m : Type u_2) →
(n : Type u_3) →
(o : Type u_4) →
(α : Type u_12) → [DecidableEq o] → [inst : AddZeroClass α] → (o → Matrix m n α) →+ Matrix (m × o) (n × o) α | `Matrix.blockDiagonal` as an `AddMonoidHom`. | true |
_private.Mathlib.CategoryTheory.Triangulated.TriangleShift.0.CategoryTheory.Pretriangulated.Triangle.shiftFunctor._simp_1 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Polynomial.content.eq_1 | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] (p : Polynomial R),
p.content = p.support.gcd p.coeff | null | true |
_private.Mathlib.Tactic.ClickSuggestions.Util.0.Mathlib.Tactic.ClickSuggestions.Premise.toString.match_1 | Mathlib.Tactic.ClickSuggestions.Util | (motive : Mathlib.Tactic.ClickSuggestions.Premise → Sort u_1) →
(x : Mathlib.Tactic.ClickSuggestions.Premise) →
((name : Lean.Name) → motive (Mathlib.Tactic.ClickSuggestions.Premise.const name)) →
((name : Lean.Name) → motive (Mathlib.Tactic.ClickSuggestions.Premise.fvar { name := name })) → motive x | null | false |
QuaternionAlgebra.instStarRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (a b : QuaternionAlgebra R c₁ c₂ c₃), star (a + b) = star a + star b | null | false |
CochainComplex.singleFunctors._proof_8 | Mathlib.Algebra.Homology.HomotopyCategory.SingleFunctors | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (n m a a' a'' : ℤ) (ha' : n + a = a') (ha'' : m + a' = a''),
CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => Cat... | null | false |
CategoryTheory.Functor.sheafInducedTopologyEquivOfIsCoverDense._proof_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) [G.LocallyCoverDense K] [G.IsLocallyFull K] [G.IsLocallyFaithful K]
[G.IsCoverDense K], G.IsContinuous (G.induc... | null | false |
Semiquot.IsPure | Mathlib.Data.Semiquot | {α : Type u_1} → Semiquot α → Prop | Assert that a `Semiquot` contains only one possible value. | true |
CategoryTheory.Limits.CatCospanTransform.category | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{A' : Type u₄} →
{B' : Type u₅} →
{C' : Type u₆} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
... | null | true |
Vector.map_zip_eq_zipWith | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} {f : α × β → γ} {as : Vector α n} {bs : Vector β n},
Vector.map f (as.zip bs) = Vector.zipWith (Function.curry f) as bs | null | true |
Lean.Grind.AC.Seq.startsWithVar_k_cons | Init.Grind.AC | ∀ (y x : Lean.Grind.AC.Var) (s : Lean.Grind.AC.Seq), (Lean.Grind.AC.Seq.cons y s).startsWithVar_k x = (x == y) | null | true |
Std.Http.URI.EncodedString.new | Std.Http.Data.URI.Encoding | {r : UInt8 → Bool} →
(ba : ByteArray) →
Std.Http.URI.IsAllowedEncodedChars r ba →
Std.Http.URI.isValidPercentEncoding ba = true → Std.Http.URI.EncodedString r | Creates an `EncodedString` from a `ByteArray` with compile-time proofs.
Use this when you have proofs that the byte array is valid.
| true |
LieAlgebra.LoopAlgebra.residuePairing._proof_3 | Mathlib.Algebra.Lie.Loop | ∀ (R : Type u_1) (A : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup A] [inst_4 : DistribSMul A R] (Φ : LinearMap.BilinForm R L)
(f x y : LieAlgebra.loopAlgebra R A L),
(((LieAlgebra.LoopAlgebra.toFinsupp R A L) (x + y)).sum fun a v =>
a • ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.