name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MeasureTheory.memLp_zero_iff_aestronglyMeasurable._simp_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε}, MeasureTheory.MemLp f 0 μ = MeasureTheory.AEStronglyMeasurable f μ | false |
instDecidablePredPermMemSetDerangements | Mathlib.Combinatorics.Derangements.Finite | {α : Type u_1} → [DecidableEq α] → [Fintype α] → DecidablePred fun x => x ∈ derangements α | true |
MulOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α] (x : αᵐᵒᵖ), 1 * x = x | false |
Submodule.range_inclusion | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M) (h : p ≤ q), (Submodule.inclusion h).range = Submodule.comap q.subtype p | true |
MulEquiv.AddMonoid.End._proof_1 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {M : Type u_1} [inst : AddMonoid M] (x x_1 : AddMonoid.End M),
AddMonoidHom.toMultiplicative.toFun (x * x_1) = AddMonoidHom.toMultiplicative.toFun (x * x_1) | false |
CommRingCat.tensorProd_map_right | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] {X Y : CategoryTheory.Under R} (f : X ⟶ Y),
((R.tensorProd S).map f).right =
CommRingCat.ofHom ↑(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom f)) | true |
Std.Tactic.BVDecide.Normalize.Bool.ite_else_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {α : Sort u_1} (c0 c1 : Bool) {a b : α}, (bif c0 then a else bif c1 then a else b) = bif !c0 && !c1 then b else a | true |
InitialSeg.transPrincipal_apply | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
[inst : IsWellOrder β s] [inst_1 : IsTrans γ t] (f : InitialSeg r s) (g : PrincipalSeg s t) (a : α),
(f.transPrincipal g).toRelEmbedding a = g.toRelEmbedding (f a) | true |
ModuleCat.HasLimits.limitCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_3, max u_2 u_3} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (x x_1 : J)
(f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((Categor... | false |
MulEquiv.piCongrRight_symm | Mathlib.Algebra.Group.Equiv.Basic | ∀ {η : Type u_16} {Ms : η → Type u_17} {Ns : η → Type u_18} [inst : (j : η) → Mul (Ms j)]
[inst_1 : (j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j),
(MulEquiv.piCongrRight es).symm = MulEquiv.piCongrRight fun i => (es i).symm | true |
LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L)
{K' : LieSubalgebra R L} (h : K ≤ K'),
(∃ I, LieIdeal.toLieSubalgebra R (↥K') I = LieSubalgebra.ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_nil_eq_iff_true.match_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} (motive : [] ≠ [] → Prop) (h : [] ≠ []), motive h | false |
Submodule.ClosedComplemented.complement | Mathlib.Topology.Algebra.Module.LinearMap | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_2} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → {p : Submodule R M} → [T1Space ↥p] → p.ClosedComplemented → Submodule R M | true |
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | ∀ (f : Type u₀ → Type u₁) [inst : EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (x : f α),
(EquivFunctor.mapEquiv f e) x = EquivFunctor.map e x | true |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), a.bit1.testBit 0 = true | true |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Epi f] {Z : C}
(g h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h → g = h | true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | (motive : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog → Sort u_1) →
(__discr : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog) →
((header : Lean.TSyntax `Lean.Parser.Module.header) →
(parserState : Lean.Parser.ModuleP... | false |
Std.Time.Hour.instLEOffset._aux_1 | Std.Time.Time.Unit.Hour | Std.Time.Hour.Offset → Std.Time.Hour.Offset → Prop | false |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F] {L : E →L[... | true |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
X.ofLEMk f h =
CategoryTheory.CategoryStruct.comp (X.ofLE (CategoryTheory.Subobject.mk f) h)
(CategoryTheory.Subobjec... | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuseCmd_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Command.CommandElab | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | ∀ {ι : Type u_1} {s : Finset ι} (motive : Subtype (Membership.mem s) → Prop) (x : Subtype (Membership.mem s)),
(∀ (i : ι) (hi : i ∈ s), motive ⟨i, hi⟩) → motive x | false |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List α | true |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] {m : M} (motive : IsAddUnit m → Prop) (h : IsAddUnit m),
(∀ (u : AddUnits M) (hu : ↑u = m), motive ⋯) → motive h | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : DivInvMonoid α], ULift.divInvMonoid = Function.Injective.divInvMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | true |
IsInvariantSubfield.mk._flat_ctor | Mathlib.FieldTheory.Fixed | ∀ {M : Type u} [inst : Monoid M] {F : Type v} [inst_1 : Field F] [inst_2 : MulSemiringAction M F] {S : Subfield F},
(∀ (m : M) {x : F}, x ∈ S → m • x ∈ S) → IsInvariantSubfield M S | false |
Aesop.LocalRuleSet.mk.sizeOf_spec | Aesop.RuleSet | ∀ (toBaseRuleSet : Aesop.BaseRuleSet) (simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems))
(simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size) (simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs))
(simprocsArrayNonempty : 0 < simprocsArray.size) (localNormSimpRules : Array Aesop.LocalNormSimpRul... | true |
Matroid.cRk_map_image._auto_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | Lean.Syntax | false |
VectorAll._unsafe_rec | Mathlib.Data.Vector3 | {α : Type u_1} → (k : ℕ) → (Vector3 α k → Prop) → Prop | false |
Std.DTreeMap.Raw.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k fallback : α},
(t.erase k).isEmpty = false →
¬cmp k (t.minKeyD fallback) = Ordering.eq → (t.erase k).minKeyD fallback = t.minKeyD fallback | true |
CategoryTheory.MonoOver.mapIso._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : C} (e : A ≅ B) (X : CategoryTheory.MonoOver A),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoOver.map e.hom).map
(((CategoryTheory.MonoOver.mapComp e.hom e.inv).symm ≪≫
CategoryTheory.eqToIso ⋯ ≪≫ Category... | false |
pow_nonneg._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀],
0 ≤ a → ∀ (n : ℕ), (0 ≤ a ^ n) = True | false |
Lean.Data.AC.evalList._sparseCasesOn_1.else_eq | Init.Data.AC | ∀ {α : Type u} {motive : List α → Sort u_1} (t : List α) (nil : motive [])
(«else» : Nat.hasNotBit 1 t.ctorIdx → motive t) (h : Nat.hasNotBit 1 t.ctorIdx),
Lean.Data.AC.evalList._sparseCasesOn_1 t nil «else» = «else» h | false |
Int.le_of_not_le | Init.Data.Int.Order | ∀ {a b : ℤ}, ¬a ≤ b → b ≤ a | true |
Topology.IsLowerSet.WithLowerSetHomeomorph | Mathlib.Topology.Order.UpperLowerSetTopology | {α : Type u_1} →
[inst : Preorder α] → [inst_1 : TopologicalSpace α] → [Topology.IsLowerSet α] → Topology.WithLowerSet α ≃ₜ α | true |
Nat.eq_or_lt_of_le._unsafe_rec | Init.Prelude | ∀ {n m : ℕ}, n ≤ m → n = m ∨ n < m | false |
ShareCommon.StateFactoryImpl.setFind? | Init.ShareCommon | (self : ShareCommon.StateFactoryImpl) → self.Set → ShareCommon.Object → Option ShareCommon.Object | true |
Equiv.Perm.isCycleOn_swap | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {a b : α} [inst : DecidableEq α], a ≠ b → (Equiv.swap a b).IsCycleOn {a, b} | true |
Mathlib.Tactic.ComputeDegree.natDegree_natCast_le | Mathlib.Tactic.ComputeDegree | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (↑n).natDegree ≤ 0 | true |
PresheafOfModules.evaluationJointlyReflectsColimits._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
(c : CategoryTheory.Limits.Cocone F)
(hc : (X : Cᵒᵖ) → CategoryTheory.Limits.IsColimit ((Presh... | false |
Specialization.map_id | Mathlib.Topology.Specialization | ∀ {α : Type u_1} [inst : TopologicalSpace α], Specialization.map (ContinuousMap.id α) = OrderHom.id | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | false |
Matrix.IsSymm.fromBlocks | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, A.IsSymm → B.transpose = C → D.IsSymm → (Matrix.fromBlocks A B C D).IsSymm | true |
Lean.Server.Reference.ci | Lean.Server.References | Lean.Server.Reference → Lean.Elab.ContextInfo | true |
Mathlib.pp.mathlib.binderPredicates | Mathlib.Util.PPOptions | Lean.Option Bool | true |
Set.iUnion_comm | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} (s : ι → ι' → Set α), ⋃ i, ⋃ i', s i i' = ⋃ i', ⋃ i, s i i' | true |
Mathlib.Tactic.AtomM.Context.mk._flat_ctor | Mathlib.Util.AtomM | Lean.Meta.TransparencyMode → (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Mathlib.Tactic.AtomM.Context | false |
Units.val_eq_neg_one | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] {a : αˣ}, ↑a = -1 ↔ a = -1 | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_trans._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | false |
_private.Mathlib.Data.Finset.Lattice.Basic.0.Finset.instDistribLattice._simp_1 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
MulRingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : NonAssocRing R] → MulRingNorm R → AddGroupNorm R | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | false |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | Mathlib.RingTheory.Invariant.Profinite | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {G : Type u_3}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [SMulCommClass G A B] [inst_6 : TopologicalSpace G]
[CompactSpace G] [TotallyDisconnectedSpace G] [IsTopologicalGroup G] [inst_10 : TopologicalSpace B]
... | true |
Algebra.Extension.Hom.mk.inj | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S} {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} {inst_3 : CommRing R'} {inst_4 : CommRing S'} {inst_5 : Algebra R' S'}
{P' : Algebra.Extension R' S'} {inst_6 : Algebra R R'} {inst_7 : Algebra S S'} {toRingHom : ... | true |
Perfection.coeff_mk | Mathlib.RingTheory.Perfection | ∀ {R : Type u_1} [inst : CommSemiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (f : ℕ → R)
(hf : ∀ (n : ℕ), f (n + 1) ^ p = f n) (n : ℕ), (Perfection.coeff R p n) ⟨f, hf⟩ = f n | true |
Function.Semiconj.comp_eq | Mathlib.Logic.Function.Conjugate | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β}, Function.Semiconj f ga gb → f ∘ ga = gb ∘ f | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.varMap._default | Lean.Meta.Tactic.Simp.Arith.Int.Basic | Lean.Meta.KExprMap ℕ | false |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._proof_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, ¬(¬xs.size - 1 < xs.size ↔ xs.size = 0) → False | false |
prod_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u_3} {β : Type u_4} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [ProperSpace α]
[ProperSpace β], ProperSpace (α × β) | true |
Preord.ofHom_id | Mathlib.Order.Category.Preord | ∀ {X : Type u} [inst : Preorder X],
Preord.ofHom OrderHom.id = CategoryTheory.CategoryStruct.id { carrier := X, str := inst } | true |
HasFDerivWithinAt.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{f' g' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → HasFDerivWithinAt g g' s ... | true |
Filter.le_limsup_iff' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β}
[DenselyOrdered β] {x : β},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._auto_1 →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._au... | true |
Lean.Meta.Sym.AlphaShareCommon.State.set._default | Lean.Meta.Sym.AlphaShareCommon | Lean.PHashSet Lean.Meta.Sym.AlphaKey | false |
MonadControl.noConfusionType | Init.Control.Basic | Sort u_1 →
{m : Type u → Type v} →
{n : Type u → Type w} →
MonadControl m n → {m' : Type u → Type v} → {n' : Type u → Type w} → MonadControl m' n' → Sort u_1 | false |
AlgebraicGeometry.«term_⤏_» | Mathlib.AlgebraicGeometry.RationalMap | Lean.TrailingParserDescr | true |
_private.Mathlib.Data.PNat.Basic.0.PNat.dvd_iff._simp_1_1 | Mathlib.Data.PNat.Basic | ∀ (n : ℕ+), (↑n = 0) = False | false |
CategoryTheory.InducedCategory.Hom.mk | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (F X ⟶ F Y) → X.Hom Y | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntry?ₘ'.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
[inst : Ord α] →
(motive : (Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) → Sort u_3) →
(step : Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) →
((ky : α) →
(a : Ordering.lt = Ordering.lt) →
... | true |
_private.Lean.Meta.Tactic.Simp.Arith.Nat.Simp.0.Lean.Meta.Simp.Arith.Nat.simpCnstr?.match_1 | Lean.Meta.Tactic.Simp.Arith.Nat.Simp | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__discr : Option (Lean.Expr × Lean.Expr)) →
((eNew' h₂ : Lean.Expr) → motive (some (eNew', h₂))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive __discr | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.nz_of_isRat.match_1_1 | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [inst : Ring A]
(motive : Mathlib.Meta.NormNum.IsRat e n d → decide (n < 0) = true → Prop) (x : Mathlib.Meta.NormNum.IsRat e n d)
(x_1 : decide (n < 0) = true),
(∀ (inv : Invertible ↑d) (eq : e = ↑n * ⅟↑d) (h : decide (n < 0) = true), motive ⋯ h) → motive x x_1 | false |
FiniteField.frobenius_pow | Mathlib.FieldTheory.Finite.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p : ℕ} [inst_2 : Fact (Nat.Prime p)] [inst_3 : CharP K p]
{n : ℕ}, Fintype.card K = p ^ n → frobenius K p ^ n = 1 | true |
IsDiscreteValuationRing.unit_mul_pow_congr_unit | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsDiscreteValuationRing R] {ϖ : R},
Irreducible ϖ → ∀ (u v : Rˣ) (m n : ℕ), ↑u * ϖ ^ m = ↑v * ϖ ^ n → u = v | true |
ContinuousLinearEquiv.toDiffeomorph._proof_2 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(e : E ≃L[𝕜] E'), ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') ↑⊤ ⇑e | false |
Fin.foldrM_succ | Init.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Type u_1} [inst : Monad m] [LawfulMonad m] (f : Fin (n + 1) → α → m α),
Fin.foldrM (n + 1) f = fun x => Fin.foldrM n (fun i => f i.succ) x >>= f 0 | true |
Lean.ppNoDotAttr._regBuiltin.Lean.ppNoDotAttr.declRange_3 | Lean.PrettyPrinter.Delaborator.Attributes | IO Unit | false |
PiTensorProduct.mapLMonoidHom._proof_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {ι : Type u_2} [inst : Fintype ι] {𝕜 : Type u_3} [inst_1 : NontriviallyNormedField 𝕜] {E : ι → Type u_1}
[inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)],
ContinuousAdd (PiTensorProduct 𝕜 fun i => E i) | false |
Filter.CountableGenerateSets.below.basic | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_2} {g : Set (Set α)} {motive : (a : Set α) → Filter.CountableGenerateSets g a → Prop} {s : Set α}
(a : s ∈ g), Filter.CountableGenerateSets.below ⋯ | true |
List.sum_set | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (L : List M) (n : ℕ) (a : M),
(L.set n a).sum = ((List.take n L).sum + if n < L.length then a else 0) + (List.drop (n + 1) L).sum | true |
LinearMap.convOne_apply | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_1} {A : Type u_2} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C] (c : C),
(WithConv.ofConv 1) c = (algebraMap R A) (CoalgebraStruct.counit c) | true |
Lean.IR.IRType.below | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} → Lean.IR.IRType → Sort (max 1 u) | false |
_private.Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno.0.OrderedFinpartition.eraseMiddle._simp_5 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit | true |
Localization.algEquiv_symm_mk | Mathlib.RingTheory.Localization.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
(Localization.algEquiv M S).symm (IsLocalization.mk' S x y) = Localization.mk x y | true |
String.ofList._proof_1 | Init.Prelude | ∀ (data : List Char), data.utf8Encode.IsValidUTF8 | false |
Subfield.instMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u_2} [inst : DivisionRing K] {X : Type u_1} [inst_1 : MulAction K X] (b : X), 1 • b = b | false |
CategoryTheory.Limits.biprod.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X X_1 : C) (e_X : X = X_1) (Y Y_1 : C) (e_Y : Y = Y_1) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
(X ⊞ Y) = (X_1 ⊞ Y_1) | true |
Std.Time.FormatType | Std.Time.Format.Basic | Type → Std.Time.FormatString → Type | true |
Matrix.addGroup._proof_4 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : AddGroup α],
autoParam (∀ (n_1 : ℕ) (a : Matrix m n α), (fun i => Int.negSucc n_1 • a i) = -fun i => ↑n_1.succ • a i)
SubNegMonoid.zsmul_neg'._autoParam | false |
_private.Mathlib.RingTheory.MvPowerSeries.Trunc.0.MvPowerSeries.coeff_trunc'_mul_trunc'_eq_coeff_mul._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} [inst : DecidableEq σ] (n : σ →₀ ℕ) ⦃a b : σ →₀ ℕ⦄, b ≤ a → a ∈ ↑(Finset.Iic n) → b ∈ ↑(Finset.Iic n) | false |
IsIntegrallyClosed.of_iInf_eq_bot | Mathlib.RingTheory.LocalProperties.IntegrallyClosed | ∀ {R : Type u_1} {K : Type u_2} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{ι : Type u_3} (S : ι → Subalgebra R K), (∀ (i : ι), IsIntegrallyClosed ↥(S i)) → ⨅ i, S i = ⊥ → IsIntegrallyClosed R | true |
_private.Lean.Message.0.Lean.MessageData.hasSyntheticSorry.visit._sparseCasesOn_1 | Lean.Message | {motive_1 : Lean.MessageData → Sort u} →
(t : Lean.MessageData) →
((f : Option Lean.PPContext → BaseIO Dynamic) →
(hasSyntheticSorry : Lean.MetavarContext → Bool) → motive_1 (Lean.MessageData.ofLazy f hasSyntheticSorry)) →
((a : Lean.MessageDataContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.Me... | false |
conjneg_ne_zero | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 0 ↔ f ≠ 0 | true |
_private.Lean.Elab.Print.0.Lean.Elab.Command.printStructure._sparseCasesOn_3 | Lean.Elab.Print | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Lean.Elab.FieldRedeclInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.FieldRedeclInfo → Sort u} →
(t : Lean.Elab.FieldRedeclInfo) → ((stx : Lean.Syntax) → motive { stx := stx }) → motive t | false |
Multiset.disjoint_finset_sum_left | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} {i : Finset ι} {f : ι → Multiset α} {a : Multiset α},
Disjoint (i.sum f) a ↔ ∀ b ∈ i, Disjoint (f b) a | true |
Finsupp.mem_range_mapDomain_iff | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (f : α → β),
Function.Injective f → ∀ (x : β →₀ M), x ∈ Set.range (Finsupp.mapDomain f) ↔ ∀ b ∉ Set.range f, x b = 0 | true |
_private.Lean.Elab.PreDefinition.Main.0.Lean.Elab.isNonRecursive | Lean.Elab.PreDefinition.Main | Lean.Elab.PreDefinition → Bool | true |
Std.Time.DateTime.ofPlainDateTimeAssumingUTC | Std.Time.Zoned.DateTime | Std.Time.PlainDateTime → (tz : Std.Time.TimeZone) → Std.Time.DateTime tz | true |
Turing.ToPartrec.instDecidableEqCode | Mathlib.Computability.TuringMachine.Config | DecidableEq Turing.ToPartrec.Code | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.