name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._proof_1_7 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K : Set α} {s : Set (Set α)},
s ⊆ 𝒫 K →
∀ (S : Set (Set (Set α))),
∀ L ∈ s,
L \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ⊆ K \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ∩ L | false |
Alexandrov.principals | Mathlib.Topology.Sheaves.Alexandrov | (X : Type v) →
[inst : TopologicalSpace X] →
[inst_1 : Preorder X] → [Topology.IsUpperSet X] → CategoryTheory.Functor X (TopologicalSpace.Opens X)ᵒᵖ | true |
ComplexShape.σ_symm | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₁₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] [inst_1 : TotalComplexShape c₂ c₁ c₁₂]
[inst_2 : TotalComplexShapeSymmetry c₁ c₂ c₁₂] [inst_3 : TotalComplexShapeSymmetry c₂ c₁ c₁₂]
[TotalComplexShapeSymm... | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core.match_3 | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
{a b : Q(«$α»)} →
(motive : Mathlib.Meta.NormNum.Result a → Mathlib.Meta.NormNum.Result b → Sort u_1) →
(ra : Mathlib.Meta.NormNum.Result a) →
(rb : Mathlib.Meta.NormNum.Result b) →
((val : Bool) →
(proof : Lean.Expr) →
... | false |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew._sparseCasesOn_3 | Mathlib.Util.WhatsNew | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
NonUnitalSubsemiring.instBot._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a + b ∈ {0} | false |
_private.Lean.Compiler.LCNF.DependsOn.0.Lean.Compiler.LCNF.LetDecl.depOn | Lean.Compiler.LCNF.DependsOn | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.M✝ Bool | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.getPolyConst.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | (motive : Lean.Grind.CommRing.Poly → Sort u_1) →
(p : Lean.Grind.CommRing.Poly) →
((k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k)) → ((x : Lean.Grind.CommRing.Poly) → motive x) → motive p | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.cRk_map_image_lift._simp_1_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | false |
FreeAddSemigroup.rec._@.Mathlib.Algebra.Free.2508704951._hygCtx._hyg.3 | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeAddSemigroup α → Sort u_1} →
((head : α) → (tail : List α) → motive { head := head, tail := tail }) → (t : FreeAddSemigroup α) → motive t | false |
Lean.Grind.CommRing.Mon.concat.eq_1 | Init.Grind.Ring.CommSolver | ∀ (m₂ : Lean.Grind.CommRing.Mon), Lean.Grind.CommRing.Mon.unit.concat m₂ = m₂ | true |
EmbeddingLike.casesOn | Mathlib.Data.FunLike.Embedding | {F : Sort u_1} →
{α : Sort u_2} →
{β : Sort u_3} →
[inst : FunLike F α β] →
{motive : EmbeddingLike F α β → Sort u} →
(t : EmbeddingLike F α β) → ((injective' : ∀ (f : F), Function.Injective ⇑f) → motive ⋯) → motive t | false |
Substring.Raw.Valid.validFor | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∃ l m r, Substring.Raw.ValidFor l m r s | true |
LinearIsometry.rTensor_apply | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] (f : E →ₗᵢ[𝕜] F) (x : TensorProduct... | true |
ArchimedeanClass.stdPart_sub_eq_left | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x y : K},
0 < ArchimedeanClass.mk y → ArchimedeanClass.stdPart (x - y) = ArchimedeanClass.stdPart x | true |
Std.Tactic.BVDecide.LRAT.Internal.instBEqDefaultClause.beq._proof_4 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {numVarsSucc : ℕ} (a b : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin numVarsSucc))
(h : (a == b) = true), ⋯ ≍ ⋯ | false |
Lean.Elab.Command.elabElabRules._regBuiltin.Lean.Elab.Command.elabElabRules.declRange_3 | Lean.Elab.ElabRules | IO Unit | false |
Mathlib.Tactic.RingNF.Config | Mathlib.Tactic.Ring.RingNF | Type | true |
_private.Mathlib.Order.Defs.Unbundled.0.of_eq.match_1_1 | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} (motive : (x x_1 : α) → x = x_1 → Prop) (x x_1 : α) (x_2 : x = x_1),
(∀ (x : α), motive x x ⋯) → motive x x_1 x_2 | false |
AlgebraicGeometry.Scheme.Cover.glueMorphisms._proof_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Cover.ulift 𝒰).fromGlued | false |
MonadShareCommon.mk._flat_ctor | Init.ShareCommon | {m : Type u → Type v} → ({α : Type u} → α → m α) → MonadShareCommon m | false |
ContinuousMap.norm_eq_iSup_norm | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] (f : C(α, E)), ‖f‖ = ⨆ x, ‖f x‖ | true |
LinearMap.smulRightₗ | Mathlib.Algebra.Module.LinearMap.End | {R : Type u_1} →
{M : Type u_4} →
{M₂ : Type u_6} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M] → [inst_4 : Module R M₂] → (M₂ →ₗ[R] R) →ₗ[R] M →ₗ[R] M₂ →ₗ[R] M | true |
StrictMono.wellFoundedLT | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} [WellFoundedLT β],
StrictMono f → WellFoundedLT α | true |
_private.Mathlib.Data.Fin.Basic.0.Fin.exists_eq_add_of_lt._simp_1_3 | Mathlib.Data.Fin.Basic | ∀ {n m : ℕ}, (n < m) = (↑n < ↑m) | false |
Set.mem_smul | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {s : Set α} {t : Set β} {b : β},
b ∈ s • t ↔ ∃ x ∈ s, ∃ y ∈ t, x • y = b | true |
Append.mk.noConfusion | Init.Prelude | {α : Type u} →
{P : Sort u_1} →
{append append' : α → α → α} → { append := append } = { append := append' } → (append ≍ append' → P) → P | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Comma.0.CategoryTheory.MorphismProperty.instIsClosedUnderIsomorphismsOverOverObjOfRespectsIso._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {W : CategoryTheory.MorphismProperty T} {X : T}
[W.RespectsIso], W.overObj.IsClosedUnderIsomorphisms | false |
MeasureTheory.SimpleFunc.integral_smul | 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 : DistribSMul 𝕜 E] [SMulCommClass ℝ 𝕜 E] (c : 𝕜)
{f : MeasureTheory.SimpleFunc α E},
MeasureTheory.Integrable (⇑f) μ →
MeasureTheory.SimpleF... | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.go._unsafe_rec | Lean.Compiler.LCNF.Types | Lean.Expr → Lean.MetaM Lean.Expr | false |
Finpartition.map | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{β : Type u_2} →
[inst_2 : Lattice β] → [inst_3 : OrderBot β] → {a : α} → (e : α ≃o β) → Finpartition a → Finpartition (e a) | true |
Graph.not_isLink_of_notMem_edgeSet | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, e ∉ G.edgeSet → ¬G.IsLink e x y | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks.0.CategoryTheory.Limits.PreservesPullback.iso_inv_fst._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | false |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.instLawfulSliceSizeTakeListIteratorIdListSliceData._simp_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u} {s : ListSlice α}, Std.ToIterator.iter s = Std.Slice.Internal.iter s | false |
NonUnitalStarAlgebra.adjoinNonUnitalCommSemiringOfComm.match_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {s : Set A} (motive : ↥(NonUnitalStarAlgebra.adjoin R s) → Prop)
(x : ↥(N... | false |
AddMonoidAlgebra.of'_mul_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G] (a : G)
(x : AddMonoidAlgebra k G), (AddMonoidAlgebra.of' k G a * x).divOf a = x | true |
CategoryTheory.Sheaf.ΓNatIsoLim | Mathlib.CategoryTheory.Sites.GlobalSections | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
[inst_2 : CategoryTheory.HasWeakSheafify J A] →
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape Cᵒᵖ A] →
... | true |
ISize.add_assoc | Init.Data.SInt.Lemmas | ∀ (a b c : ISize), a + b + c = a + (b + c) | true |
PolynomialModule.eval_smul | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Polynomial R)
(q : PolynomialModule R M) (r : R),
(PolynomialModule.eval r) (p • q) = Polynomial.eval r p • (PolynomialModule.eval r) q | true |
_private.Std.Sync.Barrier.0.Std.BarrierState.mk._flat_ctor | Std.Sync.Barrier | ℕ → ℕ → Std.BarrierState✝ | false |
Std.Time.TimeZone.TZif.instInhabitedTZif | Std.Time.Zoned.Database.TzIf | Inhabited Std.Time.TimeZone.TZif.TZif | true |
_private.LeanSearchClient.Syntax.0.LeanSearchClient.checkTactic.match_1 | LeanSearchClient.Syntax | (motive : List Lean.MVarId × Lean.Elab.Term.State → Sort u_1) →
(__discr : List Lean.MVarId × Lean.Elab.Term.State) →
((goals : List Lean.MVarId) → (snd : Lean.Elab.Term.State) → motive (goals, snd)) → motive __discr | false |
Lean.Compiler.LCNF.isClass? | Lean.Compiler.LCNF.Types | Lean.Expr → Lean.CoreM (Option Lean.Name) | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers.0.CategoryTheory.NormalMonoCategory.pullback_of_mono.match_1_3 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasFiniteProducts C] [inst_3 : CategoryTheory.Limits.HasKernels C] {X Z : C}
(a : X ⟶ Z) (P : C) (f : Z ⟶ P) (haf : CategoryTheory.CategoryStruct.comp a f = 0) (Q : C) (... | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.withSynthesizeImp.match_1 | Lean.Elab.SyntheticMVars | {α : Type} →
(motive : DoResultPR α α PUnit.{1} → Sort u_1) →
(r : DoResultPR α α PUnit.{1}) →
((a : α) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : α) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | false |
PresheafOfModules.Sheafify.SMulCandidate.casesOn | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} →
{R : CategoryTheory.Sheaf J RingCat} →
{α : R₀ ⟶ R.obj} →
{M₀ : PresheafOfModules R₀} →
{A : CategoryTheory.Shea... | false |
Vector.insertIdx | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i ≤ n) Vector.insertIdx._auto_1 → Vector α (n + 1) | true |
MulOpposite.op_ne_zero_iff | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Zero α] (a : α), MulOpposite.op a ≠ 0 ↔ a ≠ 0 | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvLetValue._sparseCasesOn_15 | Lean.Compiler.LCNF.AlphaEqv | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.unbox fvarId h)) →
(Nat.hasNotBit 16384 t.ctorIdx → mot... | false |
Class._aux_Mathlib_SetTheory_ZFC_Class___unexpand_Class_sUnion_1 | Mathlib.SetTheory.ZFC.Class | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.Composition.recOnSingleAppend.match_3.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (motive : (n : ℕ) → Composition n → Sort u_1) (blocks : List ℕ) (blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i)
(h_1 :
(blocks : List ℕ) →
(blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i) →
motive blocks.sum { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ }),
(match blocks.sum, { blocks :... | true |
ProbabilityTheory.exponentialPDF_of_nonneg | Mathlib.Probability.Distributions.Exponential | ∀ {r x : ℝ}, 0 ≤ x → ProbabilityTheory.exponentialPDF r x = ENNReal.ofReal (r * Real.exp (-(r * x))) | true |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?!_snd | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {v : β},
(Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?! t k v).2 = Std.DTreeMap.Internal.Impl.insertIfNew! k v t | true |
LLVM.AttributeIndex.ctorIdx | Lean.Compiler.IR.LLVMBindings | LLVM.AttributeIndex → ℕ | false |
_private.Mathlib.MeasureTheory.Integral.DominatedConvergence.0.MeasureTheory.integral_tsum._simp_1_2 | Mathlib.MeasureTheory.Integral.DominatedConvergence | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (a : E), ‖a‖ = ↑‖a‖₊ | false |
HasFPowerSeriesAt.hasFDerivAt | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {f : E → F} {x : E},
HasFPowerSeriesAt f p x → HasFDerivAt f ((continuousMult... | true |
LaurentSeries.ratfuncAdicComplRingEquiv._proof_3 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K] (x y : LaurentSeries.RatFuncAdicCompl K),
(LaurentSeries.comparePkg K).toFun (x * y) =
(LaurentSeries.comparePkg K).toFun x * (LaurentSeries.comparePkg K).toFun y | false |
Finset.cons.congr_simp | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (a a_1 : α) (e_a : a = a_1) (s s_1 : Finset α) (e_s : s = s_1) (h : a ∉ s),
Finset.cons a s h = Finset.cons a_1 s_1 ⋯ | true |
Fintype.card_lt_of_injective_of_notMem | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
Function.Injective f → ∀ {b : β}, b ∉ Set.range f → Fintype.card α < Fintype.card β | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.mkLambdaFVarsWithLetDeps | Lean.Meta.ExprDefEq | Array Lean.Expr → Lean.Expr → Lean.MetaM (Option Lean.Expr) | true |
FiniteIndexNormalAddSubgroup.instSemilatticeInfFiniteIndexNormalAddSubgroup._proof_3 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {x y : FiniteIndexNormalAddSubgroup G}, ↑y < ↑x ↔ ↑y < ↑x | false |
Lean.Elab.Term.elabRawNatLit._regBuiltin.Lean.Elab.Term.elabRawNatLit.declRange_3 | Lean.Elab.BuiltinTerm | IO Unit | false |
Std.Do.PredTrans.const | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → Std.Do.Assertion ps → Std.Do.PredTrans ps α | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Complex.ofReal_cpow._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {z : ℝ}, (↑z = 0) = (z = 0) | false |
Sym.countPerms_coe_fill_of_notMem | Mathlib.Data.Nat.Choose.Multinomial | ∀ {n : ℕ} {α : Type u_1} [inst : DecidableEq α] {m : Fin (n + 1)} {s : Sym α (n - ↑m)} {x : α},
x ∉ s → (↑(Sym.fill x m s)).countPerms = n.choose ↑m * (↑s).countPerms | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.IsAddCyclic.of_exponent_eq_card.match_1_1 | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddCommGroup α] (val : Fintype α)
(motive : (∃ a ∈ Finset.univ, addOrderOf a = (Finset.image addOrderOf Finset.univ).max' ⋯) → Prop)
(x : ∃ a ∈ Finset.univ, addOrderOf a = (Finset.image addOrderOf Finset.univ).max' ⋯),
(∀ (g : α) (left : g ∈ Finset.univ) (hg : addOrderOf g = (Finset.image... | false |
Int64.shiftLeft_zero | Init.Data.SInt.Bitwise | ∀ {a : Int64}, a <<< 0 = a | true |
TopologicalSpace.gciGenerateFrom | Mathlib.Topology.Order | (α : Type u_1) →
GaloisCoinsertion (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual) | true |
isArtinian_of_finite | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Finite M],
IsArtinian R M | true |
Std.TreeSet.instSliceableRocSlice | Std.Data.TreeSet.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.instSliceableRocSlice._auto_1) →
Std.Roc.Sliceable (Std.TreeSet α cmp) α (Std.DTreeMap.Internal.Unit.RocSlice α) | true |
Vector.finRange_zero | Init.Data.Vector.FinRange | Vector.finRange 0 = #v[] | true |
Lean.Elab.Level.Context.mk | Lean.Elab.Level | Lean.Options → Lean.Syntax → Bool → Lean.Elab.Level.Context | true |
_private.Mathlib.Data.Nat.Bitwise.0.Nat.xor_mod_two_eq._simp_1_6 | Mathlib.Data.Nat.Bitwise | ∀ {n : ℕ}, (n % 2 ≠ 0) = (n % 2 = 1) | false |
List.pair_mem_product | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : List α} {ys : List β} {x : α} {y : β}, (x, y) ∈ xs.product ys ↔ x ∈ xs ∧ y ∈ ys | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushInstPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit | true |
_private.Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar.0.BoundedContinuousFunction.mem_charPoly._simp_1_1 | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
{f g : BoundedContinuousFunction α β}, (f = g) = ∀ (x : α), f x = g x | false |
NumberField.InfinitePlace.mk_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {φ : L →+* ℂ},
φ ∈ NumberField.ComplexEmbedding.mixedEmbeddingsOver L v.embedding →
NumberField.InfinitePlace.mk φ ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v | true |
CpltSepUniformSpace.ctorIdx | Mathlib.Topology.Category.UniformSpace | CpltSepUniformSpace → ℕ | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.instInhabitedVarInfo.default | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.VarInfo✝ | true |
Nat.Partition.ofSums._proof_1 | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ (l : Multiset ℕ) {i : ℕ}, i ∈ Multiset.filter (fun x => x ≠ 0) l → ⊥ < i | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitLet.match_1 | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE binderName type value body nondep)) →
((x : Lean.Expr) → motive x) → motive e | false |
VitaliFamily.FineSubfamilyOn.covering.congr_simp | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
{v v_1 : VitaliFamily μ} (e_v : v = v_1) {f f_1 : X → Set (Set X)} (e_f : f = f_1) {s s_1 : Set X} (e_s : s = s_1)
(_h : v.FineSubfamilyOn f s) (a a_1 : X × Set X),
a = a_1 → ∀ (a_2 a_3 : X), a_2 = a_3 → _h.coveri... | true |
Std.Roc.lower | Init.Data.Range.Polymorphic.PRange | {α : Type u} → Std.Roc α → α | true |
NumberField.InfinitePlace.liesOver_embedding_of_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {w : NumberField.InfinitePlace L},
w ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v → NumberField.ComplexEmbedding.LiesOver w.embedding v.embedding | true |
Std.DTreeMap.toList | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List ((a : α) × β a) | true |
List.filterMap_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {L : List (List α)},
List.filterMap f L.flatten = (List.map (List.filterMap f) L).flatten | true |
IsLocalDiffeomorph.preimage_boundary | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : 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... | true |
CategoryTheory.Abelian.SpectralObject.mono_map | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι) {i₀' i₀ i₁ i₂ i₃ : ι}
(f₁ : i₀ ⟶ i₁) (f₁' : i₀' ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(α : CategoryTheory.... | true |
Complex.basisOneI._proof_6 | Mathlib.LinearAlgebra.Complex.Module | NeZero (1 + 1) | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.prod_involution._proof_1_3 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} (s : Finset ι) (g : (a : ι) → a ∈ s → ι),
(∀ (a : ι) (ha : a ∈ s), g a ha ∈ s) → ∀ (x : ι) (hx : x ∈ s) (ha : g x ⋯ ∈ s), g (g x ⋯) ha ∈ s | false |
QuadraticForm.equivalent_weightedSumSquares_units_of_nondegenerate' | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_3} {V : Type u_8} [inst : Field K] [inst_1 : Invertible 2] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[FiniteDimensional K V] (Q : QuadraticForm K V),
LinearMap.SeparatingLeft (QuadraticMap.associated Q) →
∃ w, QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares K w) | true |
NNReal.tendsto_const_div_atTop_nhds_zero_nat | Mathlib.Analysis.SpecificLimits.Basic | ∀ {𝕜 : Type u_4} [inst : DivisionSemiring 𝕜] [inst_1 : CharZero 𝕜] [inst_2 : TopologicalSpace 𝕜] [ContinuousSMul ℚ≥0 𝕜]
[ContinuousMul 𝕜] (C : 𝕜), Filter.Tendsto (fun n => C / ↑n) Filter.atTop (nhds 0) | true |
Lean.Elab.Tactic.evalConstructor._regBuiltin.Lean.Elab.Tactic.evalConstructor_1 | Lean.Elab.Tactic.ElabTerm | IO Unit | false |
Equiv.Perm.card_cycleType_pos | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α}, 0 < σ.cycleType.card ↔ σ ≠ 1 | true |
_private.Lean.Meta.Offset.0.Lean.Meta.isNatZero | Lean.Meta.Offset | Lean.Expr → Lean.MetaM Bool | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.curriedActionMonoidal._proof_21 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_2, u_1} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (x : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
((Catego... | false |
Std.CloseableChannel.tryRecv | Std.Sync.Channel | {α : Type} → Std.CloseableChannel α → BaseIO (Option α) | true |
Sigma.instIsTransLex | Mathlib.Data.Sigma.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} [IsTrans ι r]
[∀ (i : ι), IsTrans (α i) (s i)], IsTrans ((i : ι) × α i) (Sigma.Lex r s) | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mintro_1 | Std.Tactic.Do.Syntax | Lean.Macro | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.