name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsGreatest.pi_norm | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {E : Type u_3} [inst : Fintype ι] [inst_1 : SeminormedAddGroup E] [Nonempty ι] (f : ι → E),
IsGreatest (Set.range fun x => ‖f x‖) ‖f‖ | null | true |
Float32.Model.rec._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.337 | Mathlib.Util.CompileInductive | {motive : Float32.Model → Sort u} →
((toBits : UInt32) →
(valid : Float.Model.Format.binary32.Valid toBits.toBitVec) → motive { toBits := toBits, valid := valid }) →
(t : Float32.Model) → motive t | null | false |
Std.ExtHashMap.size_insertIfNew_le | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {v : β}, (m.insertIfNew k v).size ≤ m.size + 1 | null | true |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort_of_pairwise._proof_1_4 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (a b : α) (xs : List α),
(↑(List.MergeSort.Internal.splitInTwo ⟨a :: b :: xs, ⋯⟩).1).length < xs.length + 1 + 1 →
¬xs.length + 1 + 1 - (xs.length + 1 + 1 + 1) / 2 < xs.length + 1 + 1 → False | null | false |
AdicCompletion.AdicCauchySequence.instSMulNat | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u_4) →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → SMul ℕ (AdicCompletion.AdicCauchySequence I M) | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.ofNat_add._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int32.ofNat n = Int32.ofInt ↑n | null | false |
ProbabilityTheory.riskIncrease_le_iInf | Mathlib.Probability.Decision.Risk.RiskIncrease | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
[inst : MeasurableSpace 𝓨] {π : MeasureTheory.Measure Θ} {P : ProbabilityTheory.Kernel Θ 𝓧} {ℓ : Θ → 𝓨 → ENNReal},
Measurable (Function.uncurry ℓ) →
∀ [ProbabilityTheory.IsMarkovKernel P] [MeasureTheory.SFini... | null | true |
CategoryTheory.Functor.OplaxMonoidal.copy._auto_3 | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
Pi.constNonUnitalRingHom._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonUnitalNonAssocSemiring β] (x y : β),
(NonUnitalRingHom.pi fun x => NonUnitalRingHom.id β).toFun (x * y) =
(NonUnitalRingHom.pi fun x => NonUnitalRingHom.id β).toFun x *
(NonUnitalRingHom.pi fun x => NonUnitalRingHom.id β).toFun y | null | false |
Lean.Compiler.LCNF.LetDecl.updateValue | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetDecl pu →
Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.LetDecl pu) | null | true |
Monotone.measure_iInter | Mathlib.MeasureTheory.Measure.Continuity | ∀ {α : Type u_1} {ι : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : ι → Set α}
[inst : Preorder ι] [IsCodirectedOrder ι] [Filter.atBot.IsCountablyGenerated],
Monotone s → (∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) → (∃ i, μ (s i) ≠ ⊤) → μ (⋂ i, s i) = ⨅ i, μ (s i) | **Continuity from above**:
the measure of the intersection of a monotone family of measurable sets
indexed by a type with countably generated `atBot` filter
is equal to the infimum of the measures. | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.denote'_addConst_eq | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p : Int.Internal.Linear.Poly) (a : ℤ),
Int.Internal.Linear.Poly.denote' ctx (p.addConst a) = Int.Internal.Linear.Poly.denote ctx p + a | null | true |
List.firstM._unsafe_rec | Init.Data.List.Control | {m : Type u → Type v} → [Alternative m] → {α : Type w} → {β : Type u} → (α → m β) → List α → m β | null | false |
AddChar.instDecidableEq | Mathlib.Algebra.Group.AddChar | {A : Type u_1} → {M : Type u_3} → [inst : AddMonoid A] → [inst_1 : Monoid M] → DecidableEq (AddChar A M) | null | true |
CategoryTheory.Limits.WidePushoutShape.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | Sort u →
{J : Type w} →
{a a_1 : CategoryTheory.Limits.WidePushoutShape J} →
a.Hom a_1 → {J' : Type w} → {a' a'_1 : CategoryTheory.Limits.WidePushoutShape J'} → a'.Hom a'_1 → Sort u | null | false |
TopologicalSpace.NonemptyCompacts.isPreconnected_Iic | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K : TopologicalSpace.NonemptyCompacts α},
IsPreconnected ↑K → IsPreconnected (Set.Iic K) | null | true |
_private.Mathlib.Data.Set.Card.0.Set.ncard_congr._simp_1_2 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s : Set α), s.ncard = Nat.card ↑s | null | false |
UniformContinuous₂.bicompl | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} {δ' : Type u_2} [inst : UniformSpace α]
[inst_1 : UniformSpace β] [inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] [inst_4 : UniformSpace δ']
{f : α → β → γ} {ga : δ → α} {gb : δ' → β},
UniformContinuous₂ f → UniformContinuous ga → UniformContinuous gb ... | null | true |
_private.Mathlib.Topology.Partial.0.pcontinuous_iff'._simp_1_2 | Mathlib.Topology.Partial | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (s ∈ nhds x) = ∃ t ⊆ s, IsOpen t ∧ x ∈ t | null | false |
CategoryTheory.pullbackShiftIso.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) (a : A) (b : B) (h : b = φ a),
CategoryTheory.pullbackShiftIso C φ a b h = CategoryTheory.eqToIso ⋯ | null | true |
Coalgebra.TensorProduct.lid._proof_5 | Mathlib.RingTheory.Coalgebra.TensorProduct | ∀ (R : Type u_2) (P : Type u_1) [inst : CommSemiring R] [inst_1 : AddCommMonoid P] [inst_2 : Module R P],
Function.RightInverse (TensorProduct.lid R P).invFun (↑(TensorProduct.lid R P)).toFun | null | false |
NNReal.sqrt_inv | Mathlib.Analysis.Real.Sqrt | ∀ (x : NNReal), NNReal.sqrt x⁻¹ = (NNReal.sqrt x)⁻¹ | null | true |
Ordinal.iSup_lt_of_lt_cof | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {α : Type u} {f : α → Ordinal.{u}} {a : Ordinal.{u}}, Cardinal.mk α < a.cof → (∀ (i : α), f i < a) → ⨆ i, f i < a | null | true |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_eq_zero_of_eq_nat._proof_1_4 | Mathlib.Algebra.Lie.Sl2 | (1 + 1).AtLeastTwo | null | false |
Std.DHashMap.Const.ofList_cons | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
Std.DHashMap.Const.ofList ((k, v) :: tl) = Std.DHashMap.Const.insertMany (∅.insert k v) tl | null | true |
Submodule.projectionOnto_apply_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.Projection | ∀ {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}
(h : IsCompl p q) {x : E}, ((p.projectionOnto q h) x = 0) = (x ∈ q) | null | false |
_private.Mathlib.Algebra.Order.Module.Defs.0.smul_eq_smul_iff_eq_and_eq_of_pos._simp_1_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ ¬a < b) | null | false |
PreTilt.instCommRing._proof_17 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) (a b c : PreTilt O p), a * b * c = a * (b * c) | null | false |
NormalizationMonoid.casesOn | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_2} →
[inst : MonoidWithZero α] →
{motive : NormalizationMonoid α → Sort u} →
(t : NormalizationMonoid α) →
((normUnit : α → αˣ) →
(normUnit_zero : normUnit 0 = 1) →
(normUnit_one : normUnit 1 = 1) →
(normUnit_mul_units : ∀ {a : α} (u : αˣ), a ≠ 0... | null | false |
FiniteField.frobeniusAlgEquivOfAlgebraic._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) [inst : Field K], IsDomain K | null | false |
_private.Mathlib.Algebra.Free.0.FreeAddMagma.liftAux.match_1.eq_2 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeAddMagma α → Sort u_2) (x y : FreeAddMagma α)
(h_1 : (x : α) → motive (FreeAddMagma.of x)) (h_2 : (x y : FreeAddMagma α) → motive (x.add y)),
(match x.add y with
| FreeAddMagma.of x => h_1 x
| x.add y => h_2 x y) =
h_2 x y | null | true |
CategoryTheory.ShortComplex.ShortExact.exactAt_X₃._auto_1 | Mathlib.Algebra.Homology.HomologySequenceLemmas | Lean.Syntax | null | false |
MulChar.exists_apply_ne_one_of_hasEnoughRootsOfUnity | Mathlib.NumberTheory.MulChar.Duality | ∀ (M : Type u_1) (R : Type u_2) [inst : CommMonoid M] [inst_1 : CommRing R] [Finite M]
[HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] [Nontrivial R] {a : M}, a ≠ 1 → ∃ χ, χ a ≠ 1 | If `M` is a finite commutative monoid and `R` is a ring that has enough roots of unity,
then for each `a ≠ 1` in `M`, there exists a multiplicative character `χ : M → R` such that
`χ a ≠ 1`. | true |
Filter.addCommMonoid | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [AddCommMonoid α] → AddCommMonoid (Filter α) | `Filter α` is an `AddCommMonoid` under pointwise operations if `α` is. | true |
CategoryTheory.Functor.quotientCompMapHomotopyCategoryPlusIso_inv_app_hom | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive]
(X : CochainComplex.Plus C),
(F.quotientCompMapHomo... | null | true |
Lean.Parser.ParserCacheEntry.mk.inj | Lean.Parser.Types | ∀ {stx : Lean.Syntax} {lhsPrec : ℕ} {newPos : String.Pos.Raw} {errorMsg : Option Lean.Parser.Error}
{stx_1 : Lean.Syntax} {lhsPrec_1 : ℕ} {newPos_1 : String.Pos.Raw} {errorMsg_1 : Option Lean.Parser.Error},
{ stx := stx, lhsPrec := lhsPrec, newPos := newPos, errorMsg := errorMsg } =
{ stx := stx_1, lhsPrec :=... | null | true |
Finmap.toFinmap_nil | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α], [].toFinmap = ∅ | null | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_7 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Std.Time.DayPeriod.rec | Std.Time.Format.Modifier | {motive : Std.Time.DayPeriod → Sort u} →
motive Std.Time.DayPeriod.am →
motive Std.Time.DayPeriod.pm →
motive Std.Time.DayPeriod.noon → motive Std.Time.DayPeriod.midnight → (t : Std.Time.DayPeriod) → motive t | null | false |
Lean.Elab.Tactic.BVDecide.SolverMode.proof | Std.Tactic.BVDecide.Syntax | Lean.Elab.Tactic.BVDecide.SolverMode | Set SAT solver options to improve proof search.
| true |
AlgebraicGeometry.Scheme.empty._proof_1 | Mathlib.AlgebraicGeometry.Scheme | CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology ↑↧PEmpty.{u_1 + 1})
((CategoryTheory.Functor.const (TopologicalSpace.Opens ↑↧PEmpty.{u_1 + 1})ᵒᵖ).obj ↧PUnit.{u_1 + 1}) | null | false |
LieEquiv.symm_apply_eq | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) {x : L₂} {y : L₁}, e.symm x = y ↔ x = e y | null | true |
Lean.instValueLeanOptionValue | Lean.Util.LeanOptions | Lean.KVMap.Value Lean.LeanOptionValue | null | true |
Set.iUnion_Icc_left | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] (a : α), ⋃ b, Set.Icc b a = Set.Iic a | null | true |
IsChain.image_relEmbedding_iff | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α} {φ : r ↪r r'},
IsChain r' (⇑φ '' s) ↔ IsChain r s | null | true |
CategoryTheory.MorphismProperty.shiftLocalizerMorphism | Mathlib.CategoryTheory.Shift.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(W : CategoryTheory.MorphismProperty C) →
{A : Type w} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
[W.IsCompatibleWithShift A] → A → CategoryTheory.LocalizerMorphism W W | The morphism of localizer from `W` to `W` given by the functor `shiftFunctor C a`
when `a : A` and `W` is compatible with the shift by `A`. | true |
groupCohomologyIsoExt | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) →
(n : ℕ) → groupCohomology A n ≅ ((Ext k (Rep.{u, u, u} k G) n).obj (Opposite.op (Rep.trivial k G k))).obj A | The `n`th group cohomology of a `k`-linear `G`-representation `A` is isomorphic to
`Extⁿ(k, A)` (taken in `Rep k G`), where `k` is a trivial `k`-linear `G`-representation. | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {n : ℕ}, (n = 1) = (n ∣ 1) | null | false |
SSet.stdSimplex.objMk₁._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j₁ j₂ : Fin ((Opposite.unop (Opposite.op { len := n })).len + 1)),
j₁ ≤ j₂ → (fun j => if j.castSucc < i then 0 else 1) j₁ ≤ (fun j => if j.castSucc < i then 0 else 1) j₂ | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.Mk₁.map_id.match_1_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (motive : Fin 2 → Prop) (i : Fin 2), (∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → motive i | null | false |
Aesop.Frontend.Parser.featIdent | Aesop.Frontend.RuleExpr | Lean.ParserDescr | null | true |
Lean.Order.instCCPOSTOfNonempty._proof_1 | Init.Internal.Order.MonadTail | ∀ {σ : Type} (s : Void σ), Nonempty (Void σ) | null | false |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.isUniformInducing_pi_restrict._simp_1_2 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {uγ : UniformSpace γ} {f : α → β} {g : β → γ},
UniformSpace.comap f (UniformSpace.comap g uγ) = UniformSpace.comap (g ∘ f) uγ | null | false |
Filter.Frequently.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∃ᶠ (x : α) in f, q x | null | true |
CategoryTheory.CatEnrichedOrdinary.Hom.ext | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{f g : X ⟶ Y} (α β : f ⟶ g),
CategoryTheory.CatEnrichedOrdinary.Hom.base α = CategoryTheory.CatEnrichedOrdinary.Hom.base β → α = β | null | true |
CoeT.rec | Init.Coe | {α : Sort u} →
{x : α} →
{β : Sort v} → {motive : CoeT α x β → Sort u_1} → ((coe : β) → motive { coe := coe }) → (t : CoeT α x β) → motive t | null | false |
_private.Mathlib.Order.UpperLower.Basic.0.IsUpperSet.top_mem.match_1_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} {s : Set α} (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (_a : α) (ha : _a ∈ s), motive ⋯) → motive x | null | false |
LieAlgebra.zeroRootSubalgebra_eq_iff_is_cartan | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] [IsNoetherian R L],
LieAlgebra.zeroRootSubalgebra R L H = H ↔ H.IsCartanSubalgebra | null | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S}
{h : CategoryTheory.Limits.ChosenPullback f₁ f₂} {Y : C} {g₁ : Y ⟶ X₁} {g₂ : Y ⟶ X₂} {b : Y ⟶ S} {f : Y ⟶ h.pullback}
{f_p₁ :
autoParam (CategoryTheory.CategoryStruct.comp f h.p₁ = g₁)
CategoryTheory.Limits.... | null | true |
PointedCone.mem_dual | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R} {s : Set M} {y : N}, y ∈ PointedCone.dual p s ↔ ∀ ⦃x : M⦄, x ∈ s → 0 ≤... | null | true |
_private.Mathlib.Analysis.Normed.Field.WithAbs.0.AbsoluteValue.Completion.algebraOfLiesOver._proof_4 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {K : Type u_1} [inst : Field K] (v : AbsoluteValue K ℝ) {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
(w : AbsoluteValue L ℝ) [w.LiesOver v], Continuous ⇑(WithAbs.map v w (algebraMap K L)) | null | false |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.mapsTo_restrict_maxGenEigenspace_restrict_of_mapsTo._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CategoryTheory.ShortComplex.leftHomologyMapIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap e.inv)... | null | false |
Aesop.preTraverseUp | Aesop.Tree.Traversal | {m : Type → Type} →
[Monad m] →
[MonadLiftT (ST IO.RealWorld) m] →
(Aesop.GoalRef → m Bool) → (Aesop.RappRef → m Bool) → (Aesop.MVarClusterRef → m Bool) → Aesop.TreeRef → m Unit | null | true |
Array._aux_Init_Data_Array_Mem___macroRules_tacticDecreasing_trivial_2 | Init.Data.Array.Mem | Lean.Macro | null | false |
PUnit.instCompleteLinearOrder._proof_3 | Mathlib.Order.CompleteLattice.Lemmas | ∀ (a b c : PUnit.{u_1 + 1}), a \ b ≤ c ↔ a ≤ max b c | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.tacticC_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | Lean.ParserDescr | null | true |
WithConv.toConv_ofConv | Mathlib.Algebra.WithConv | ∀ {A : Type u_2} (x : WithConv A), WithConv.toConv x.ofConv = x | null | true |
_private.Mathlib.Tactic.Echelon.Reflection.0.Mathlib.Tactic.Echelon.getD_of_isLowerTriangularDiagList._proof_1_1 | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} [inst : Zero α] {k : ℕ} {rows : List (List α)} {i : ℕ},
i < 0 → ¬(rows.getD i []).getD (k + i) 0 = 0 ∧ ∀ (j : ℕ), k + i < j → (rows.getD i []).getD j 0 = 0 | null | false |
Metric.unitBall.instSemigroup._proof_3 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (a b c : ↑(Metric.ball 0 1)), a * b * c = a * (b * c) | null | false |
Lean.Meta.Grind.CasesEntry.casesOn | Lean.Meta.Tactic.Grind.Cases | {motive : Lean.Meta.Grind.CasesEntry → Sort u} →
(t : Lean.Meta.Grind.CasesEntry) →
((declName : Lean.Name) → (eager : Bool) → motive { declName := declName, eager := eager }) → motive t | null | false |
CategoryTheory.Limits.CategoricalPullback.mkIso._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{x y : CategoryTheory.Limits.CategoricalPullback F G} (eₗ :... | null | false |
Field.sepDegree | Mathlib.FieldTheory.SeparableClosure | (F : Type u) → (E : Type v) → [inst : Field F] → [inst_1 : Field E] → [Algebra F E] → Cardinal.{v} | The (infinite) separable degree for a general field extension `E / F` is defined
to be the degree of `separableClosure F E / F`. | true |
HasProdUniformly.multipliableUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α}
[inst_1 : UniformSpace α], HasProdUniformly f g → MultipliableUniformly f | null | true |
Associates.instCommMonoid._proof_5 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), ⟦a * 1⟧ = ⟦a⟧ | null | false |
CategoryTheory.Over.monObjMkPullbackSnd_mul | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.MonObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal... | null | true |
Real.eq_one_of_pos_of_log_eq_zero | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {x : ℝ}, 0 < x → Real.log x = 0 → x = 1 | null | true |
CategoryTheory.Limits.biprod.add_eq_lift_id_desc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} (f g : X ⟶ Y)
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X X],
f + g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biprod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheo... | The existence of binary biproducts implies that there is at most one preadditive structure. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triple_eq_triple_of_mem._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
MeasureTheory.measure_lt_top_of_isCompact_of_isAddLeftInvariant' | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.IsAddLeftInvariant] {U : Set G},
(interior U).Nonempty → μ U ≠ ⊤ → ∀ {K : Set G}, IsCompact K → μ K < ⊤ | If a left-invariant measure gives finite mass to a set with nonempty interior, then it gives
finite mass to any compact set. | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_6 | Mathlib.Analysis.Complex.Conformal | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Polynomial.trailingDegree_eq_zero._simp_1 | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.trailingDegree = 0) = (p.coeff 0 ≠ 0) | null | false |
groupCohomology.mapShortComplex₁_exact | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) {i j : ℕ} (hij : i + 1 = j), (groupCohomology.mapShortComplex₁ hX hij).Exact | Exactness of `Hⁱ(G, X₃) ⟶ Hʲ(G, X₁) ⟶ Hʲ(G, X₂)`. | true |
TopCat.isColimitCoconeOfForget | Mathlib.Topology.Category.TopCat.Limits.Basic | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J TopCat} →
(c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget TopCat))) →
CategoryTheory.Limits.IsColimit c → CategoryTheory.Limits.IsColimit (TopCat.coconeOfCoconeForget c) | Given a functor `F : J ⥤ TopCat` and a cocone `c : Cocone (F ⋙ forget)`
of the underlying cocone of types, the colimit of `F` is `c.pt` equipped
with the supremum of the coinduced topologies by the maps `c.ι.app j`. | true |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.deleteEdges_isLoopAt._simp_1_2 | Mathlib.Combinatorics.Graph.Delete | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
SlashInvariantForm.coe_const | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetOne] (x : ℂ),
⇑(SlashInvariantForm.const x) = Function.const UpperHalfPlane x | null | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr},
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg c_1 → c = c_1 | null | true |
Std.Time.TimeZone.TZif.TZifV2.mk.noConfusion | Std.Time.Zoned.Database.TzIf | {P : Sort u} →
{toTZifV1 : Std.Time.TimeZone.TZif.TZifV1} →
{footer : Option String} →
{toTZifV1' : Std.Time.TimeZone.TZif.TZifV1} →
{footer' : Option String} →
{ toTZifV1 := toTZifV1, footer := footer } = { toTZifV1 := toTZifV1', footer := footer' } →
(toTZifV1 = toTZifV1' → f... | null | false |
SimpleGraph.degree_lt_card_sub_one | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] (v : V),
G.degree v < Fintype.card V - 1 ↔ ¬G.IsUniversal v | null | true |
FormalMultilinearSeries.rightInv._proof_14 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E | null | false |
CategoryTheory.Functor.instLaxMonoidalActionMapAction._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} V] {G : Type u_3} [inst_1 : Monoid G] {W : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} W] [inst_3 : CategoryTheory.MonoidalCategory V]
[inst_4 : CategoryTheory.MonoidalCategory W] (F : CategoryTheory.Functor V W) [inst_5 : F.LaxMonoidal]
(X Y ... | null | false |
ValuationRing.mk._flat_ctor | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {A : Type u} [inst : CommRing A] [inst_1 : IsDomain A], (∀ (a b : A), ∃ c, a * c = b ∨ b * c = a) → ValuationRing A | null | false |
MeasureTheory.average_fun_finsetSum | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure α} {ι : Type u_4} {s : Finset ι} {f : ι → α → E},
(∀ i ∈ s, MeasureTheory.Integrable (f i) μ) → ⨍ (a : α), ∑ c ∈ s, f c a ∂μ = ∑ i ∈ s, ⨍ (a : α), f i a ∂μ | Eta-expanded form of `MeasureTheory.average_finsetSum` | true |
Lean.Lsp.instOrdPosition | Lean.Data.Lsp.BasicAux | Ord Lean.Lsp.Position | null | true |
MeasureTheory.condExpL2_comp_continuousLinearMap | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {α : Type u_1} {E' : Type u_3} (𝕜 : Type u_7) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E']
[inst_2 : InnerProductSpace 𝕜 E'] [inst_3 : CompleteSpace E'] [inst_4 : NormedSpace ℝ E'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {E'' : Type u_8} (𝕜' : Type u_9) [inst_5 : RCLike 𝕜'] [inst_6 : N... | null | true |
Int.one_ne_zero | Init.Data.Int.Order | 1 ≠ 0 | null | true |
CategoryTheory.MorphismProperty.ofHoms_iff | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_3} {X Y : ι → C} (f : (i : ι) → X i ⟶ Y i)
{A B : C} (g : A ⟶ B),
CategoryTheory.MorphismProperty.ofHoms f g ↔ ∃ i, CategoryTheory.Arrow.mk g = CategoryTheory.Arrow.mk (f i) | null | true |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.isSafeExpansionFailedException.match_1 | Aesop.Search.ExpandSafePrefix | (motive : Lean.Exception → Sort u_1) →
(x : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive x | null | false |
Fin.attachFin_Ioo | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a b : Fin n), (Finset.Ioo ↑a ↑b).attachFin ⋯ = Finset.Ioo a b | null | true |
Submodule.LinearDisjoint.one_left | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (N : Submodule R S),
Submodule.LinearDisjoint 1 N | The image of `R` in `S` is linearly disjoint with any other submodules. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.