name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Inclusion.InclusionM.Context.noConfusionType | Mathlib.Tactic.Inclusion.Core.Types | Sort u → Inclusion.InclusionM.Context → Inclusion.InclusionM.Context → Sort u | null | false |
UniformSpaceCat.completionFunctor._proof_2 | Mathlib.Topology.Category.UniformSpace | ∀ {X Y Z : UniformSpaceCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.ConcreteCategory.ofHom
⟨UniformSpace.Completion.map ⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩).hom) =
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct... | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.WorkGroup✝ → Std.Format.WorkGroup✝ → Sort u | null | false |
integral_bilinear_hasLineDerivAt_right_eq_neg_left_of_integrable | Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts | ∀ {E : Type u_1} {F : Type u_2} {G : Type u_3} {W : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
[inst_6 : NormedAddCommGroup W] [inst_7 : NormedSpace ℝ W] [inst_8 : Measurable... | **Integration by parts for line derivatives**
Version with a general bilinear form `B`.
If `B f g` is integrable, as well as `B f' g` and `B f g'` where `f'` and `g'` are derivatives
of `f` and `g` in a given direction `v`, then `∫ B f g' = - ∫ B f' g`. | true |
BitVec.instHashable | Init.Data.BitVec.Basic | {n : ℕ} → Hashable (BitVec n) | null | true |
OrderRingHom.comp_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
[inst_3 : Preorder β] (f : α →+*o β), f.comp (OrderRingHom.id α) = f | null | true |
isLinearSet_iff_exists_fin_addMonoidHom | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsLinearSet s ↔ ∃ a n f, s = a +ᵥ Set.range ⇑f | null | true |
Std.DTreeMap.Internal.Impl.Const.minEntry._unary | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) ×' t.isEmpty = false → α × β | Implementation detail of the tree map | false |
CochainComplex.HomComplex | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → CochainComplex C ℤ → CochainComplex C ℤ → CochainComplex AddCommGrpCat ℤ | The cochain complex of homomorphisms between two cochain complexes `F` and `G`.
In degree `n : ℤ`, it consists of the abelian group `HomComplex.Cochain F G n`. | true |
Char.reduceEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.Simproc | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toArray_rio_eq_zero_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m...n).toArray[i]! = 0) = (n ≤ i + m ∨ m = 0 ∧ i = 0) | null | false |
List.perm_reverse._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse = l₁.Perm l₂ | null | false |
Vector.map_eq_flatMap | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n},
Vector.map f xs = Vector.cast ⋯ (xs.flatMap fun x => #v[f x]) | null | true |
Ordnode.map.valid | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {β : Type u_2} [inst_1 : Preorder β] {f : α → β},
StrictMono f → ∀ {t : Ordnode α}, t.Valid → (Ordnode.map f t).Valid | null | true |
CategoryTheory.Factorisation.instCategory | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.Factorisation f) | null | true |
OneHom.instCommMonoid | Mathlib.Algebra.Group.Hom.Instances | {M : Type uM} → {N : Type uN} → [inst : One M] → [inst_1 : CommMonoid N] → CommMonoid (OneHom M N) | `OneHom M N` is a `CommMonoid` if `N` is commutative. | true |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_contains_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool},
m.WF → (m.all p = false ↔ ∃ a, ∃ (h : m.contains a = true), p a (Std.DHashMap.Raw.Const.get m a h) = false) | null | true |
iff_self_and._simp_1 | Init.SimpLemmas | ∀ {p q : Prop}, (p ↔ p ∧ q) = (p → q) | null | false |
add_eq_zero_iff_eq_neg | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a + b = 0 ↔ a = -b | null | true |
MvPolynomial.map_eval₂ | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {S₃ : Type x} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
(f : R →+* S₁) (g : S₂ → MvPolynomial S₃ R) (p : MvPolynomial S₂ R),
(MvPolynomial.map f) (MvPolynomial.eval₂ MvPolynomial.C g p) =
MvPolynomial.eval₂ MvPolynomial.C (⇑(MvPolynomial.map f) ∘ g) ((MvPolyno... | null | true |
MeasureTheory.integral_comp | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {E' : Type u_2} {F' : Type u_3} {A : Type u_4} [inst : NormedAddCommGroup E'] [inst_1 : InnerProductSpace ℝ E']
[inst_2 : FiniteDimensional ℝ E'] [inst_3 : MeasurableSpace E'] [inst_4 : BorelSpace E']
[inst_5 : NormedAddCommGroup F'] [inst_6 : InnerProductSpace ℝ F'] [inst_7 : FiniteDimensional ℝ F']
[inst_8 : ... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, ∀ i' < p.length, i' ≤ p.length | null | false |
Fin.val_intCast | Mathlib.Data.ZMod.Defs | ∀ {n : ℕ} [inst : NeZero n] (x : ℤ), ↑↑x = (x % ↑n).toNat | null | true |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.isEmpty_slice._simp_1_2 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} (pos₁ pos₂ : (s.slice p₀ p₁ h).Pos),
(pos₁ = pos₂) = (String.Pos.ofSlice pos₁ = String.Pos.ofSlice pos₂) | null | false |
NumberField.exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
∃ a ∈ ↑I,
a ≠ 0 ∧
↑|(Algebra.norm ℚ) a| ≤
↑(FractionalIdeal.absNorm ↑I) * (4 / Real.pi) ^ NumberField.InfinitePlace.nrComplexPlaces K *
↑(Module.fin... | null | true |
CategoryTheory.Bicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Basic___macroRules_CategoryTheory_Bicategory_term_◁ᵢ__1» | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Macro | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.abs_dvd | Init.Data.Int.Linear | ∀ {a p : ℤ}, a ∣ p → Int.Internal.Linear.abs a ∣ p | null | true |
AddCommMonCat.equivalence._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddCommMonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))) =
CategoryTheory.CategoryStruct.comp (CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom f)))
(CommMonCat.ofHom (AddMonoidH... | null | false |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_149 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} (i j : ℕ), j < l.length → i < j → i < l.length | null | false |
AlgebraicGeometry.Scheme.Modules.restrictAdjunction._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f], IsOpenMap ⇑f | null | false |
Lean.Meta.Sym.Arith.State.mk | Lean.Meta.Sym.Arith.Types | ℕ →
Array Lean.Meta.Sym.Arith.CommRing →
Array Lean.Meta.Sym.Arith.CommSemiring →
Array Lean.Meta.Sym.Arith.Ring →
Array Lean.Meta.Sym.Arith.Semiring →
Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Sym.Arith.ClassifyResult → Lean.Meta.Sym.Arith.State | null | true |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.evalCast._sparseCasesOn_4 | Mathlib.Tactic.Ring.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) → (Nat.hasNotBit 512 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._aux_70 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | (k : Type u_1) → [Field k] → ℚ → AdjoinPthRoots k → AdjoinPthRoots k | null | false |
pi_norm_le_iff_of_nonempty' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_5} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (G i)] (f : (i : ι) → G i)
{r : ℝ} [Nonempty ι], ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_2 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
_private.Mathlib.Algebra.Polynomial.Eval.Defs.0.Polynomial.eval_natCast._simp_1_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n | null | false |
StarAlgEquiv.coe_pow | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (f : R ≃⋆ₐ[S] R)
(n : ℕ), ⇑(f ^ n) = (⇑f)^[n] | null | true |
Std.TreeSet.Raw.foldr_eq_foldr_toArray | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} {δ : Type w} {f : α → δ → δ} {init : δ},
Std.TreeSet.Raw.foldr f init t = Array.foldr f init t.toArray | null | true |
RingEquiv.restrict._proof_5 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σR : Type u_4}
{σS : Type u_2} [inst_2 : SetLike σR R] [inst_3 : SetLike σS S] [inst_4 : SubsemiringClass σR R]
[inst_5 : SubsemiringClass σS S] (e : R ≃+* S) (s' : σR) (s : σS) (h : ∀ (x : R), x ∈ s' ↔ e x ∈ s) (x : ↥s),
(... | null | false |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(c₂ : CategoryTheory.Limits.KernelFork S₂.g) (f : c₁.pt ⟶ c₂.pt),
CategoryTheory.CategoryStruct.comp... | null | false |
ContMDiff.along_snd | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | **Alias** of `ContMDiff.curry_right`.
---
Curried `C^n` functions are `C^n` in the second coordinate. | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.IsIndex.eq_of_isType₂_δ._proof_1_4 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {u : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
{l : Fin (u.dim + 1)} (i : Fin (u.dim + 2)), l.succ < i → ¬l = Fin.last u.dim | null | false |
RingHomInvPair.toRingEquiv_apply | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] (σ : R₁ →+* R₂) (σ' : R₂ →+* R₁)
[inst_2 : RingHomInvPair σ σ'] (a : R₁), (RingHomInvPair.toRingEquiv σ σ') a = σ a | null | true |
Option.attachWith_some._proof_1 | Init.Data.Option.Attach | ∀ {α : Type u_1} {x : α} {P : α → Prop}, (∀ (b : α), some x = some b → P b) → P x | null | false |
PrincipalSeg.transInitial_top | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
(f : PrincipalSeg r s) (g : InitialSeg s t), (f.transInitial g).top = g f.top | null | true |
AlgebraicGeometry.Scheme.precoverage_le_qcPrecoverage_of_isOpenMap | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme},
(P ≤ fun x x_1 f => IsOpenMap ⇑f) → AlgebraicGeometry.Scheme.precoverage P ≤ AlgebraicGeometry.Scheme.qcPrecoverage | If `P` implies being an open map, the by `P` induced precoverage is coarser
than the quasi-compact precoverage. | true |
ContinuousLinearMapWOT.seminorm._proof_3 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_4} {𝕜₂ : Type u_1} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologi... | null | false |
Subspace.dualAnnihilator_dualAnnihilator_eq | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : FiniteDimensional K V] (W : Subspace K V),
(Submodule.dualAnnihilator W).dualAnnihilator = (Module.mapEvalEquiv K V) W | null | true |
PadicInt.mahlerSeries_apply | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : Module ℤ_[p] E]
[inst_2 : IsBoundedSMul ℤ_[p] E] [IsUltrametricDist E] [CompleteSpace E] {a : ℕ → E},
Filter.Tendsto a Filter.atTop (nhds 0) → ∀ (x : ℤ_[p]), (PadicInt.mahlerSeries a) x = ∑' (n : ℕ), (mahler n) x • a n | Evaluation of a Mahler series is just the pointwise sum. | true |
Real.ofDigitsTerm_le | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} {digits : ℕ → Fin b} {n : ℕ}, Real.ofDigitsTerm digits n ≤ (↑b - 1) * (↑b ^ (n + 1))⁻¹ | null | true |
LieDerivation.SMulBracketCommClass.mk._flat_ctor | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {S : Type u_4} {L : Type u_5} {α : Type u_6} [inst : SMul S α] [inst_1 : LieRing L] [inst_2 : AddCommGroup α]
[inst_3 : LieRingModule L α],
(∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆) → LieDerivation.SMulBracketCommClass S L α | null | false |
_private.Lean.ParserCompiler.0.Lean.ParserCompiler.parserNodeKind?._sparseCasesOn_1 | Lean.ParserCompiler | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool)... | null | false |
Graph.isLink_self_iff | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G : Graph α β}, G.IsLink e x x ↔ G.IsLoopAt e x | null | true |
bernoulli_zero | Mathlib.NumberTheory.Bernoulli | bernoulli 0 = 1 | null | true |
ProbabilityTheory.CondIndepSets.bInter | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {ι : Type u_2} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
{u : Set ι},
(∃ n ∈ u, ProbabilityTheory.CondIndepSets m' hm' (s n) s' μ) →
ProbabilityThe... | null | true |
MulOpposite.instDivisionMonoid | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [DivisionMonoid α] → DivisionMonoid αᵐᵒᵖ | null | true |
IsTopologicalGroup.to_continuousDiv | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G], ContinuousDiv G | null | true |
Subsemiring.mem_toNonUnitalSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {S : Subsemiring R} {x : R}, x ∈ S.toNonUnitalSubsemiring ↔ x ∈ S | null | true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_singleton._simp_1_2 | Init.Data.String.Basic | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
_private.Mathlib.Order.Partition.Basic.0.Partition.instSemilatticeInf._proof_11 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} [inst : Order.Frame α] (s : α) (P : Partition s), ∀ p ∈ P, ∀ (q : α), ∃ y ∈ P, p ⊓ q ≤ y | null | false |
List.prod_nat_mod | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ (l : List ℕ) (n : ℕ), l.prod % n = (List.map (fun x => x % n) l).prod % n | null | true |
Archimedean.ratLt'.eq_1 | Mathlib.Basic.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : One M] (x : M),
Archimedean.ratLt' x = ⇑(Rat.castHom ℝ) '' Archimedean.ratLt x | null | true |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.initCore | Lean.Meta.Tactic.Grind.Main | Lean.MVarId → Lean.Meta.Grind.GrindM Lean.Meta.Grind.Goal | null | true |
AddSubgroup.exists_finset_card_le_add | Mathlib.GroupTheory.Schreier | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [H.FiniteIndex] {S : Finset G},
AddSubgroup.closure ↑S = ⊤ → ∃ T, T.card ≤ H.index * S.card ∧ AddSubgroup.closure ↑T = ⊤ | null | true |
Std.Internal.UV.System.GroupInfo | Std.Internal.UV.System | Type | Information about the current group,
| true |
CategoryTheory.AddGrpObj.ofIso._proof_3 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G X : C} [inst_2 : CategoryTheory.AddGrpObj G] (e : G ≅ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.id X)
(Cate... | null | false |
CategoryTheory.Limits.IsTerminal.isSplitMono_from | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X)
(f : X ⟶ Y), CategoryTheory.IsSplitMono f | Any morphism from a terminal object is split mono. | true |
CategoryTheory.Factorisation.comp_h_assoc | Mathlib.CategoryTheory.Category.Factorisation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
{X_1 Y_1 Z : CategoryTheory.Factorisation f} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z) {Z_1 : C} (h : Z.mid ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f_1 g).h h =
CategoryTheory.CategoryStruct.comp f_1.h (C... | null | true |
AddCommGroup.intIsScalarTower | Mathlib.Algebra.Module.NatInt | ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower ℤ R M | null | true |
_private.Mathlib.Analysis.Normed.Module.Multilinear.Basic.0.MultilinearMap.continuous_of_bound._simp_1_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
StateTransition.tr_eval_rev | Mathlib.Computability.StateTransition | ∀ {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop},
StateTransition.Respects f₁ f₂ tr →
∀ {a₁ : σ₁} {b₂ a₂ : σ₂},
tr a₁ a₂ → b₂ ∈ StateTransition.eval f₂ a₂ → ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁ | null | true |
StarSubalgebra.ext_iff | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S T : StarSubalgebra R A},
S = T ↔ ∀ (x : A), x ∈ S ↔ x ∈ T | null | true |
Lean.Lsp.ParameterInformation._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.ParameterInformation | null | false |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.iSup_genWeightSpace_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (N = N') = (↑N = ↑N') | null | false |
_private.Mathlib.Order.Atoms.0.IsAtom.Iic.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : Preorder α] {a x : α} (hax : a ≤ x)
(motive : (x_1 : { x_1 // x_1 ∈ Set.Iic x }) → x_1 < ⟨a, hax⟩ → Prop) (x_1 : { x_1 // x_1 ∈ Set.Iic x })
(hba : x_1 < ⟨a, hax⟩),
(∀ (b : α) (property : b ∈ Set.Iic x) (hba : ⟨b, property⟩ < ⟨a, hax⟩), motive ⟨b, property⟩ hba) → motive x_1 hba | null | false |
_private.Mathlib.Data.Finset.Basic.0.Equiv.Finset.union_symm_right._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False | null | false |
Lex.instSemifield._proof_1 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : Semifield K],
autoParam (∀ (a b : Lex K), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | null | false |
Std.TreeSet.Raw.getD_minD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.minD fallback) fallback' = t.minD fallback | null | true |
commGroupOfIsUnit | Mathlib.Algebra.Group.Units.Defs | {M : Type u_1} → [hM : CommMonoid M] → (∀ (a : M), IsUnit a) → CommGroup M | Constructs a `CommGroup` structure on a `CommMonoid` consisting only of units. | true |
_private.Lean.Meta.Tactic.Repeat.0.Lean.Meta.repeat'Core.go.match_3 | Lean.Meta.Tactic.Repeat | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
_private.Init.Data.Array.Lemmas.0.Array.back_append._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) | null | false |
Aesop.aesop.dev.generateScript | Aesop.Options.Public | Lean.Option Bool | (aesop) Only for use by Aesop developers. Generates a script even if none was requested.
| true |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.iUnion_prod_of_monotone._simp_1_4 | Mathlib.Data.Set.Lattice.Image | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.Limits.WalkingParallelFamily.equivalenceOfEquiv | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{J' : Type w'} →
J ≃ J' → (CategoryTheory.Limits.WalkingParallelFamily J ≌ CategoryTheory.Limits.WalkingParallelFamily J') | A bijection between types gives an equivalence between `WalkingParallelFamily` categories. | true |
UniformSpace.Completion.completeSpace | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α], CompleteSpace (UniformSpace.Completion α) | null | true |
SSet.PtSimplex.MulStruct.unop_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(h : g.op.MulStruct f.op fg.op i) {j : Fin n} (hij : autoParam (i.rev = j) SSet.PtSimplex.MulStruct.unop._auto_1),
(h.unop hij).map = SSet.yonedaEquiv.symm (SSet.opObjEquiv (SSet.yonedaEquiv h.map)) | null | true |
PEquiv.injective_of_forall_ne_isSome | Mathlib.Basic.PEquiv | ∀ {α : Type u} {β : Type v} (f : α ≃. β) (a₂ : α), (∀ (a₁ : α), a₁ ≠ a₂ → (f a₁).isSome = true) → Function.Injective ⇑f | If the domain of a `PEquiv` is `α` except a point, its forward direction is injective. | true |
Sum.Ioo_inr_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (b₁ b₂ : β),
Finset.Ioo (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioo b₁ b₂) | null | true |
_private.Init.Data.List.SplitOn.Lemmas.0.List.splitOnPPrepend.eq_2 | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (x : List α) (a : α) (t : List α),
List.splitOnPPrepend p (a :: t) x =
if p a = true then x.reverse :: List.splitOnPPrepend p t [] else List.splitOnPPrepend p t (a :: x) | null | true |
CompleteLattice.MulticoequalizerDiagram.multispanIndex._proof_8 | Mathlib.Order.CompleteLattice.MulticoequalizerDiagram | ∀ {T : Type u_1} [inst : CompleteLattice T] {ι : Type u_2} {x : T} {u : ι → T} {v : ι → ι → T},
CompleteLattice.MulticoequalizerDiagram x u v →
∀ (x : (CategoryTheory.Limits.MultispanShape.prod ι).L),
(match x with
| (i, j) => v i j) ≤
u ((CategoryTheory.Limits.MultispanShape.prod ι).snd x) | null | false |
CategoryTheory.Limits.IsColimit.natIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsColimit t →
((CategoryTheory.coyoneda.ob... | The colimit of `F` represents the functor taking `W` to
the set of cocones on `F` with cone point `W`. | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_2 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} {g : Equiv.Perm α} {a : α}, [a, g a, g (g a)].Nodup → ¬g a = a | null | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_π | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
inv_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (a⁻¹ < b ↔ b⁻¹ < a) | null | true |
AdjoinRoot.isAdjoinRoot._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R), RingHom.ker (AdjoinRoot.mkₐ f) = Ideal.span {f} | null | false |
AddGroupCone.nonneg_toAddSubmonoid | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : AddCommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedAddMonoid H],
(AddGroupCone.nonneg H).toAddSubmonoid = AddSubmonoid.nonneg H | null | true |
GenContFract.Pair.noConfusion | Mathlib.Algebra.ContinuedFractions.Basic | {P : Sort u} →
{α : Type u_1} →
{t : GenContFract.Pair α} →
{α' : Type u_1} → {t' : GenContFract.Pair α'} → α = α' → t ≍ t' → GenContFract.Pair.noConfusionType P t t' | null | false |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Basic.0.MeasureTheory.eLpNorm_const._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{b : β}, MeasureTheory.AEStronglyMeasurable (fun x => b) μ = True | null | false |
_private.Mathlib.Tactic.WithoutCDot.0.Lean.Elab.Term.withoutCDotContents.parenthesizer | Mathlib.Tactic.WithoutCDot | Lean.PrettyPrinter.Parenthesizer | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.