name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Fin.succFunEquiv | Mathlib.Logic.Equiv.Fin.Basic | (α : Type u_1) → (n : ℕ) → (Fin (n + 1) → α) ≃ (Fin n → α) × α | true |
NonUnitalSubring.ext | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {S T : NonUnitalSubring R}, (∀ (x : R), x ∈ S ↔ x ∈ T) → S = T | true |
Finset.mulAntidiagonal.eq_1 | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelMonoid α] {s t : Set α}
(hs : s.IsPWO) (ht : t.IsPWO) (a : α), Finset.mulAntidiagonal hs ht a = ⋯.toFinset | true |
_private.Mathlib.Data.Fin.Tuple.NatAntidiagonal.0.List.Nat.antidiagonalTuple_one._simp_1_7 | Mathlib.Data.Fin.Tuple.NatAntidiagonal | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, (List.map f l = []) = (l = []) | false |
Equiv.coe_fn_mk | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} (f : α → β) (g : β → α) (l : Function.LeftInverse g f) (r : Function.RightInverse g f),
⇑{ toFun := f, invFun := g, left_inv := l, right_inv := r } = f | true |
CoxeterSystem.IsReflection.isLeftInversion_mul_right_iff | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W},
cs.IsReflection t → ∀ {w : W}, cs.IsLeftInversion (t * w) t ↔ ¬cs.IsLeftInversion w t | true |
CochainComplex.HomComplex.Cochain.rightShiftAddEquiv._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n a n' : ℤ) (hn' : n' + a = n)
(γ : CochainComplex.HomComplex.Cochain K ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj L) n'),
(fun γ => γ.rightShift a n' hn') ((fun γ => γ.rightUnshift n hn') γ) = γ | false |
MeasureTheory.SimpleFunc.map_mul | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : Mul β] [inst_2 : Mul γ] {g : β → γ},
(∀ (x y : β), g (x * y) = g x * g y) →
∀ (f₁ f₂ : MeasureTheory.SimpleFunc α β),
MeasureTheory.SimpleFunc.map g (f₁ * f₂) = MeasureTheory.SimpleFunc.map g f₁ * MeasureTheory.SimpleFunc.map g f₂ | true |
CategoryTheory.Cat.freeMapIdIso_inv_app | Mathlib.CategoryTheory.Category.Quiv | ∀ (V : Type u_1) [inst : Quiver V] (X : CategoryTheory.Paths V),
(CategoryTheory.Cat.freeMapIdIso V).inv.app X = CategoryTheory.CategoryStruct.id X | true |
Submodule.FG.lTensor.directLimit.eq_1 | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ (R : Type u) (M : Type u_1) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : DecidableEq { Q // Q.FG }],
Submodule.FG.lTensor.directLimit R M N =
(TensorProduct.directLimitRight (fun x x_1 => Submodule.inclusion) M).symm.trans
(LinearEquiv.lTensor M (Submodule.FG.directLimit R N)) | true |
Int8.toInt32_toInt64 | Init.Data.SInt.Lemmas | ∀ (n : Int8), n.toInt64.toInt32 = n.toInt32 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_id_equiv._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) | false |
_private.Mathlib.Data.QPF.Multivariate.Constructions.Cofix.0.Mathlib.Tactic.MvBisim._aux_Mathlib_Data_QPF_Multivariate_Constructions_Cofix___elabRules_Mathlib_Tactic_MvBisim_tacticMv_bisim___With____1.match_1 | Mathlib.Data.QPF.Multivariate.Constructions.Cofix | (motive : Option (Lean.TSyntax `Lean.binderIdent) → Sort u_1) →
(x : Option (Lean.TSyntax `Lean.binderIdent)) →
((s : Lean.TSyntax `Lean.binderIdent) → motive (some s)) → (Unit → motive none) → motive x | false |
Array.findSome?_map | Init.Data.Array.Find | ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} {p : γ → Option α} {f : β → γ} {xs : Array β},
Array.findSome? p (Array.map f xs) = Array.findSome? (p ∘ f) xs | true |
AddMonoidHom.compHom._proof_1 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N]
[inst_2 : AddCommMonoid P], { toFun := AddMonoidHom.comp 0, map_zero' := ⋯, map_add' := ⋯ } = 0 | false |
_private.Init.Data.Array.Erase.0.Array.set_eraseIdx_le._proof_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {w : i < xs.size} {j : ℕ}, j < xs.size - 1 → ¬j + 1 < xs.size → False | false |
CategoryTheory.regularOfIsPullbackSndOfRegular._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S}
{k : R ⟶ S} (hr : CategoryTheory.RegularMono h)
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(t : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk f g comm))
(s :
CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.comp k hr.left)
(CategoryTheory.CategoryStruct.comp k hr.right))
(p :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
(CategoryTheory.Limits.PullbackCone.mk f g comm).pt),
CategoryTheory.CategoryStruct.comp p (CategoryTheory.Limits.PullbackCone.mk f g comm).snd = s.ι →
CategoryTheory.CategoryStruct.comp p (CategoryTheory.Limits.Fork.ofι g ⋯).ι = s.ι ∧
∀
{m :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj
(CategoryTheory.Limits.Fork.ofι g ⋯).pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero},
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Limits.Fork.ofι g ⋯).ι = s.ι → m = p | false |
Polynomial.IsSplittingField.rec | Mathlib.FieldTheory.SplittingField.IsSplittingField | {K : Type v} →
{L : Type w} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
{f : Polynomial K} →
{motive : Polynomial.IsSplittingField K L f → Sort u} →
((splits' : (Polynomial.map (algebraMap K L) f).Splits) →
(adjoin_rootSet' : Algebra.adjoin K (f.rootSet L) = ⊤) → motive ⋯) →
(t : Polynomial.IsSplittingField K L f) → motive t | false |
MeasureTheory.L1.integralCLM'.congr_simp | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} (𝕜 : Type u_4) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing 𝕜] [inst_3 : Module 𝕜 E]
[inst_4 : IsBoundedSMul 𝕜 E] [inst_5 : SMulCommClass ℝ 𝕜 E] [inst_6 : CompleteSpace E],
MeasureTheory.L1.integralCLM' 𝕜 = MeasureTheory.L1.integralCLM' 𝕜 | true |
CategoryTheory.Over.mapFunctor_obj | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ (T : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} T] (X : T),
(CategoryTheory.Over.mapFunctor T).obj X = CategoryTheory.Cat.of (CategoryTheory.Over X) | true |
_private.Mathlib.Data.List.Basic.0.List.mem_dropLast_of_mem_of_ne_getLast._proof_1_5 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α} {a : α} (ha : a ∈ l), ¬l.dropLast ++ [l.getLast ⋯] = [] | false |
_private.Mathlib.Data.Set.Inclusion.0.Set.eq_of_inclusion_surjective._proof_1_2 | Mathlib.Data.Set.Inclusion | ∀ {α : Type u_1} {s t : Set α} {h : s ⊆ t}, Function.Surjective (Set.inclusion h) → ∀ x ∈ t, x ∈ s | false |
ISize.pow_succ | Init.Data.SInt.Lemmas | ∀ (x : ISize) (n : ℕ), x ^ (n + 1) = x ^ n * x | true |
Matrix.SpecialLinearGroup.mapGL_inj | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type u_1}
[inst_3 : CommRing S] [inst_4 : Algebra R S] [FaithfulSMul R S] (g g' : Matrix.SpecialLinearGroup n R),
(Matrix.SpecialLinearGroup.mapGL S) g = (Matrix.SpecialLinearGroup.mapGL S) g' ↔ g = g' | true |
LocallyConstant.instAddMonoidWithOne._proof_4 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddMonoidWithOne Y] (x : ℕ)
(x_1 : LocallyConstant X Y), ⇑(x • x_1) = ⇑(x • x_1) | false |
Nat.stirlingSecond.eq_4 | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n k : ℕ), n.succ.stirlingSecond k.succ = (k + 1) * n.stirlingSecond (k + 1) + n.stirlingSecond k | true |
FiberBundle.extend_apply_self | Mathlib.Topology.FiberBundle.Basic | ∀ {B : Type u_2} (F : Type u_3) {E : B → Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : (x : B) → TopologicalSpace (E x)] [inst_3 : (x : B) → Zero (E x)]
[inst_4 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_5 : FiberBundle F E] {x : B} (v : E x),
FiberBundle.extend F v x = v | true |
MvPolynomial.coeffAddMonoidHom_apply | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (m : σ →₀ ℕ) (p : MvPolynomial σ R),
(MvPolynomial.coeffAddMonoidHom m) p = MvPolynomial.coeff m p | true |
Concept.instInfSet._proof_1 | Mathlib.Order.Concept | ∀ {α : Type u_1} {β : Type u_2} {r : α → β → Prop} (S : Set (Concept α β r)), Order.IsExtent r (⋂ i ∈ S, i.extent) | false |
PrimeSpectrum.closedsEmbedding | Mathlib.RingTheory.Spectrum.Prime.Topology | (R : Type u_1) → [inst : CommSemiring R] → (TopologicalSpace.Closeds (PrimeSpectrum R))ᵒᵈ ↪o Ideal R | true |
Algebra.Presentation.ofAlgEquiv_toGenerators | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Presentation R S ι σ) {T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T] (e : S ≃ₐ[R] T),
(P.ofAlgEquiv e).toGenerators = P.ofAlgEquiv e | true |
Int16.ofInt_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 16), Int16.ofInt n.toInt = Int16.ofBitVec n | true |
Std.DHashMap.Const.beq_iff_equiv | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : BEq β]
[LawfulBEq α] [LawfulBEq β], Std.DHashMap.Const.beq m₁ m₂ = true ↔ m₁.Equiv m₂ | true |
Finsupp.degree_apply | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {R : Type u_4} [inst : AddCommMonoid R] (d : σ →₀ R), Finsupp.degree d = ∑ i ∈ d.support, d i | true |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult.mk.inj | Lean.Meta.Sym.Simp.Have | ∀ {result : Lean.Meta.Sym.Simp.Result} {α : Lean.Expr} {u : Lean.Level} {result_1 : Lean.Meta.Sym.Simp.Result}
{α_1 : Lean.Expr} {u_1 : Lean.Level},
{ result := result, α := α, u := u } = { result := result_1, α := α_1, u := u_1 } →
result = result_1 ∧ α = α_1 ∧ u = u_1 | true |
continuous_norm' | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : SeminormedGroup E], Continuous fun a => ‖a‖ | true |
MonoidHom.map_mul | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N) (a b : M), f (a * b) = f a * f b | true |
Set.powersetCard.faithfulSMul | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {n : ℕ} [inst_2 : DecidableEq α],
1 ≤ n → ↑n < ENat.card α → ∀ [FaithfulSMul G α], FaithfulSMul G ↑(Set.powersetCard α n) | true |
SchwartzMap.smulLeftCLM_smul | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] {g : E → 𝕜},
Function.HasTemperateGrowth g → ∀ (c : 𝕜), SchwartzMap.smulLeftCLM F (c • g) = c • SchwartzMap.smulLeftCLM F g | true |
_private.Mathlib.Topology.Algebra.Group.Matrix.0.Matrix.SpecialLinearGroup.continuous_toGL._simp_1_1 | Mathlib.Topology.Algebra.Group.Matrix | ∀ {M : Type u_1} {X : Type u_3} [inst : TopologicalSpace M] [inst_1 : Monoid M] [inst_2 : TopologicalSpace X]
{f : X → Mˣ}, Continuous f = (Continuous (Units.val ∘ f) ∧ Continuous fun x => ↑(f x)⁻¹) | false |
Lean.Meta.getProdFields | Lean.Meta.ProdN | Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) | true |
Lean.Meta.Grind.Arith.Cutsat.CooperSplit.mk.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{pred : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred} →
{k : ℕ} →
{h : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof} →
{pred' : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred} →
{k' : ℕ} →
{h' : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof} →
{ pred := pred, k := k, h := h } = { pred := pred', k := k', h := h' } →
(pred = pred' → k = k' → h = h' → P) → P | false |
MvPolynomial.optionEquivLeft_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) [inst : CommSemiring R] (a : MvPolynomial (Option S₁) R),
(MvPolynomial.optionEquivLeft R S₁) a =
(MvPolynomial.aeval fun o => o.elim Polynomial.X fun s => Polynomial.C (MvPolynomial.X s)) a | true |
List.Ico.eq_1 | Mathlib.Data.List.Intervals | ∀ (n m : ℕ), List.Ico n m = List.range' n (m - n) | true |
CategoryTheory.Cat.comp_eq_comp | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y Z : CategoryTheory.Cat} (F : X ⟶ Y) (G : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp F G).toFunctor = F.toFunctor.comp G.toFunctor | true |
_private.Lean.Compiler.LCNF.Probing.0.Lean.Compiler.LCNF.Probe.filterByUnreach.go._unsafe_rec | Lean.Compiler.LCNF.Probing | (pu : Lean.Compiler.LCNF.Purity) →
(Lean.Expr → Lean.Compiler.LCNF.CompilerM Bool) → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.CompilerM Bool | false |
IsNowhereDense.isMeagre | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsMeagre s | true |
Turing.PartrecToTM2.K'.ofNat_ctorIdx | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : Turing.PartrecToTM2.K'), Turing.PartrecToTM2.K'.ofNat x.ctorIdx = x | true |
Matrix.blockDiag_add | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} [inst : Add α] (M N : Matrix (m × o) (n × o) α),
(M + N).blockDiag = M.blockDiag + N.blockDiag | true |
Lean.Meta.Grind.CheckResult.progress | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult | true |
Set.FiniteExhaustion.finite' | Mathlib.Data.Set.FiniteExhaustion | ∀ {α : Type u_1} {s : Set α} (self : s.FiniteExhaustion) (n : ℕ), Finite ↑(self.toFun n) | true |
MeasureTheory.Filtration.coeFn_inf | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f g : MeasureTheory.Filtration ι m},
↑(f ⊓ g) = ↑f ⊓ ↑g | true |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.DLLStorageClass.mk | Lean.Compiler.IR.LLVMBindings | UInt64 → LLVM.DLLStorageClass | true |
Orientation.oangle_sign_sub_left_eq_neg | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), (o.oangle (y - x) y).sign = -(o.oangle x y).sign | true |
PNat.dvd_antisymm | Mathlib.Data.PNat.Basic | ∀ {m n : ℕ+}, m ∣ n → n ∣ m → m = n | true |
IsRetrocompact.preimage_of_isClosedEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsClosedEmbedding f → IsCompact (Set.range f)ᶜ → IsRetrocompact s → IsRetrocompact (f ⁻¹' s) | true |
Mathlib.Tactic.Linarith.PreprocessorBase.mk.inj | Mathlib.Tactic.Linarith.Datatypes | ∀ {name : autoParam Lean.Name Mathlib.Tactic.Linarith.PreprocessorBase.name._autoParam} {description : String}
{name_1 : autoParam Lean.Name Mathlib.Tactic.Linarith.PreprocessorBase.name._autoParam} {description_1 : String},
{ name := name, description := description } = { name := name_1, description := description_1 } →
name = name_1 ∧ description = description_1 | true |
Disjoint.closure_right | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, Disjoint s t → IsOpen s → Disjoint s (closure t) | true |
NonUnitalSubring.map_id | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R),
NonUnitalSubring.map (NonUnitalRingHom.id R) s = s | true |
HasDerivAt | Mathlib.Analysis.Calculus.Deriv.Basic | {𝕜 : Type u} →
[inst : NontriviallyNormedField 𝕜] →
{F : Type v} →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] → [inst_3 : TopologicalSpace F] → [ContinuousSMul 𝕜 F] → (𝕜 → F) → F → 𝕜 → Prop | true |
MeasureTheory.FiniteMeasure.apply_iUnion_le | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {μ : MeasureTheory.FiniteMeasure Ω} {f : ℕ → Set Ω},
(Summable fun n => μ (f n)) → μ (⋃ n, f n) ≤ ∑' (n : ℕ), μ (f n) | true |
Std.DTreeMap.Raw.WF.insertMany | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] {ρ : Type u_1}
[inst : ForIn Id ρ ((a : α) × β a)] {l : ρ} {t : Std.DTreeMap.Raw α β cmp}, t.WF → (t.insertMany l).WF | true |
Finset.le_min' | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) (x : α), (∀ y ∈ s, x ≤ y) → x ≤ s.min' H | true |
Real.smoothTransition | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ℝ → ℝ | true |
DomMulAct.symm_mk_one | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : One M], DomMulAct.mk.symm 1 = 1 | true |
SSet.stdSimplex.faceRepresentableBy._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory}
(x : (SSet.stdSimplex.face S).toSSet.obj (Opposite.op j)),
∀
x_1 ∈
Finset.image
⇑(SimplexCategory.Hom.toOrderHom
(SSet.stdSimplex.objEquiv
(SSet.stdSimplex.objMk
((OrderHom.Subtype.val fun x => x ∈ S).comp
(e.toOrderEmbedding.toOrderHom.comp
(SimplexCategory.Hom.toOrderHom
(match x with
| ⟨x, hx⟩ =>
SimplexCategory.Hom.mk
{
toFun := fun i =>
e.symm ⟨(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv x)) i, ⋯⟩,
monotone' := ⋯ })))))))
⊤,
x_1 ∈ S | false |
Lean.Elab.Tactic.UnusedSimpArgsInfo._sizeOf_inst | Lean.Elab.Tactic.Simp | SizeOf Lean.Elab.Tactic.UnusedSimpArgsInfo | false |
Lean.Grind.CommRing.SPolResult.m₂ | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.SPolResult → Lean.Grind.CommRing.Mon | true |
CategoryTheory.CostructuredArrow.prodInverse._proof_1 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_7} [inst : CategoryTheory.Category.{u_5, u_7} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {C' : Type u_8} [inst_2 : CategoryTheory.Category.{u_6, u_8} C']
{D' : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D'] (S : CategoryTheory.Functor C D)
(S' : CategoryTheory.Functor C' D') (T : D) (T' : D')
{X Y : CategoryTheory.CostructuredArrow S T × CategoryTheory.CostructuredArrow S' T'} (η : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((S.prod S').map (η.1.left, η.2.left))
(CategoryTheory.CostructuredArrow.mk (Y.1.hom, Y.2.hom)).hom =
(CategoryTheory.CostructuredArrow.mk (X.1.hom, X.2.hom)).hom | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.Ctx.mk._flat_ctor | Lean.Compiler.LCNF.ExplicitBoxing | Lean.Name → Lean.Expr → Lean.Compiler.LCNF.Ctx✝ | false |
_private.Mathlib.NumberTheory.Primorial.0.Nat.Prime.dvd_primorial_iff._proof_1_1 | Mathlib.NumberTheory.Primorial | ∀ {p n : ℕ}, Nat.Prime p → p ≤ n → p ∈ {p ∈ Finset.range (n + 1) | Nat.Prime p} | false |
Option.get_dite | Init.Data.Option.Lemmas | ∀ {β : Type u_1} {p : Prop} {x : Decidable p} (b : p → β) (w : (if h : p then some (b h) else none).isSome = true),
(if h : p then some (b h) else none).get w = b ⋯ | true |
CategoryTheory.LocalizerMorphism.LeftResolution.opFunctor_obj | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) (X₂ : C₂)
(L : (Φ.LeftResolution X₂)ᵒᵖ),
(CategoryTheory.LocalizerMorphism.LeftResolution.opFunctor Φ X₂).obj L = (Opposite.unop L).op | true |
Finset.insert_inj_on | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), Set.InjOn (fun a => insert a s) (↑s)ᶜ | true |
_private.Init.Data.List.Zip.0.List.map_snd_zip.match_1_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : List α) → (x_1 : List β) → x_1.length ≤ x.length → Prop) (x : List α)
(x_1 : List β) (x_2 : x_1.length ≤ x.length),
(∀ (x : List α) (x_3 : [].length ≤ x.length), motive x [] x_3) →
(∀ (b : β) (bs : List β) (h : (b :: bs).length ≤ [].length), motive [] (b :: bs) h) →
(∀ (a : α) (as : List α) (b : β) (bs : List β) (h : (b :: bs).length ≤ (a :: as).length),
motive (a :: as) (b :: bs) h) →
motive x x_1 x_2 | false |
Polynomial.nonempty_support_iff | Mathlib.Algebra.Polynomial.Degree.Support | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.support.Nonempty ↔ p ≠ 0 | true |
_private.Lean.Elab.Print.0.Lean.Elab.Command.getFieldOrigin._sparseCasesOn_3 | Lean.Elab.Print | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
normalize_eq_zero | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, normalize x = 0 ↔ x = 0 | true |
Finpartition.IsEquipartition.card_interedges_sparsePairs_le' | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : DecidableEq α] {A : Finset α} {P : Finpartition A} {G : SimpleGraph α} [inst_4 : DecidableRel G.Adj]
{ε : 𝕜},
P.IsEquipartition →
0 ≤ ε →
↑((P.sparsePairs G ε).biUnion fun x =>
match x with
| (U, V) => G.interedges U V).card ≤
ε * (↑A.card + ↑P.parts.card) ^ 2 | true |
Lean.Grind.Order.le_eq_true_of_lt | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] {a b : α}, a < b → (a ≤ b) = True | true |
_private.Lean.Util.PPExt.0.Lean.ppTerm.match_1 | Lean.Util.PPExt | (motive : Except IO.Error Std.Format → Sort u_1) →
(__do_lift : Except IO.Error Std.Format) →
((fmt : Std.Format) → motive (Except.ok fmt)) → ((ex : IO.Error) → motive (Except.error ex)) → motive __do_lift | false |
Mathlib.Tactic.LinearCombination.smul_lt_const | Mathlib.Tactic.LinearCombination.Lemmas | ∀ {α : Type u_1} {K : Type u_2} {t s : K} [inst : Ring K] [inst_1 : PartialOrder K] [IsOrderedRing K]
[inst_3 : AddCommGroup α] [inst_4 : PartialOrder α] [IsOrderedAddMonoid α] [inst_6 : Module K α]
[IsStrictOrderedModule K α], t < s → ∀ {a : α}, 0 < a → t • a < s • a | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastShiftLeft._simp_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | false |
CongruenceSubgroup.exists_Gamma_le_conj' | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (g : GL (Fin 2) ℚ) (M : ℕ) [NeZero M],
∃ N,
N ≠ 0 ∧
ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) •
Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N) ≤
Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma M) | true |
CategoryTheory.Functor.initial_const_initial | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.IsCofiltered C] [inst_3 : CategoryTheory.Limits.HasInitial D],
((CategoryTheory.Functor.const C).obj (⊥_ D)).Initial | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass.casesOn | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | {motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass) →
((name : Lean.Name) →
(run' : Lean.MVarId → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PreProcessM (Option Lean.MVarId)) →
motive { name := name, run' := run' }) →
motive t | false |
Std.Tactic.BVDecide.BVExpr.bitblast.go._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (w : ℕ) (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (lhs : aig.RefVec w)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (rhs : aig_1.RefVec w)
(hraig : aig.decls.size ≤ { aig := aig_1, vec := rhs }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := rhs }, hraig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd (↑⟨{ aig := aig_1, vec := rhs }, hraig⟩).aig
{ lhs := lhs.cast hraig, rhs := rhs }).aig.decls.size | false |
ZFSet.Nonempty.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (u : ZFSet.{u}), u.Nonempty = (↑u).Nonempty | true |
MvPolynomial.totalDegree_pow | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (a : MvPolynomial σ R) (n : ℕ),
(a ^ n).totalDegree ≤ n * a.totalDegree | true |
OpenAddSubgroup.instSemilatticeInfOpenAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u_1} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SemilatticeInf (OpenAddSubgroup G) | true |
directedOn_ge_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), DirectedOn (fun x1 x2 => x1 ≥ x2) (Set.Icc a b) | true |
MulAction.mem_orbit_self | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] (a : α), a ∈ MulAction.orbit M a | true |
_private.Init.Data.Array.MapIdx.0.Array.mapIdx_eq_singleton_iff._simp_1_1 | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : ℕ → α → β} {b : β}, (List.mapIdx f l = [b]) = ∃ a, l = [a] ∧ f 0 a = b | false |
BiheytingHom.map_sdiff' | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_6} {β : Type u_7} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (self : BiheytingHom α β)
(a b : α), self.toFun (a \ b) = self.toFun a \ self.toFun b | true |
Array.toListRev_iterFromIdx | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {β : Type w} {array : Array β} {pos : ℕ}, (array.iterFromIdx pos).toListRev = (List.drop pos array.toList).reverse | true |
QuotientGroup.preimageMkEquivSubgroupProdSet._proof_5 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) (t : Set (α ⧸ s)) (a : ↥s × ↑t), ↑(Quotient.out ↑a.2 * ↑a.1) ∈ t | false |
Batteries.TransCmp.cmp_congr_left | Batteries.Classes.Deprecated | ∀ {α : Sort u_1} {cmp : α → α → Ordering} [Batteries.TransCmp cmp] {x y z : α},
cmp x y = Ordering.eq → cmp x z = cmp y z | true |
_private.Mathlib.Analysis.Normed.Module.FiniteDimension.0.LinearIndependent.eventually._simp_1_1 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : Fintype ι] [inst_4 : DecidableEq ι],
LinearIndependent R v = (((LinearMap.lsum R (fun x => R) ℕ) fun i => LinearMap.id.smulRight (v i)).ker = ⊥) | false |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.subset_support_tsub._simp_1_1 | Mathlib.Data.Finsupp.Order | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
Aesop.withAesopTraceNode | Aesop.Tracing | {m : Type → Type} →
{ε : Type} →
[Monad m] →
[Lean.MonadTrace m] →
[MonadLiftT BaseIO m] →
[Lean.MonadRef m] →
[Lean.AddMessageContext m] →
[Lean.MonadOptions m] →
[Lean.MonadAlwaysExcept ε m] →
{α : Type} →
[Lean.ExceptToTraceResult ε α] →
Aesop.TraceOption → (Except ε α → m Lean.MessageData) → m α → optParam Bool true → m α | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.