name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ModuleCat.smul._proof_10 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] (M : ModuleCat R) (r s : R),
AddCommGrpCat.ofHom { toFun := fun m => (r * s) • m, map_zero' := ⋯, map_add' := ⋯ } =
AddCommGrpCat.ofHom { toFun := fun m => r • m, map_zero' := ⋯, map_add' := ⋯ } *
AddCommGrpCat.ofHom { toFun := fun m => s • m, map_zero' := ⋯, map_add' := ⋯ } | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.exists_eq | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} [inst : CategoryTheory.Category.{u, u} I] {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
[inst_1 : ∀ (i : I), CompactSpace ↥(D.obj i)] [AlgebraicGeometry.LocallyOfFiniteType f]
[inst_3 : CategoryT... | true |
SemiRingCat.forget₂AddCommMonPreservesLimitsAux | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] →
CategoryTheory.Limits.IsLimit
((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).mapCone (SemiRing... | true |
_private.Mathlib.Tactic.Trace.0._aux_Mathlib_Tactic_Trace___elabRules_Lean_Parser_Tactic_trace_1.unsafe_impl_3 | Mathlib.Tactic.Trace | Lean.Expr → Lean.MetaM String | false |
Finset.mulAction._proof_1 | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : MulAction α β] (s : Finset β),
Finset.image (fun b => 1 • b) s = s | false |
ContinuousWithinAt.congr_of_eventuallyEq | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → g =ᶠ[nhdsWithin x s] f → g x = f x → ContinuousWithinAt g s x | true |
Std.TreeMap.Raw.le_maxKeyD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true | true |
CategoryTheory.SpectralSequence.Hom.noConfusion | Mathlib.Algebra.Homology.SpectralSequence.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
{t : E.Hom E'} →
... | false |
PadicInt.mahlerSeries._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | false |
AddOreLocalization.instAddMonoid | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} →
[inst : AddMonoid R] →
{S : AddSubmonoid R} → [inst_1 : AddOreLocalization.AddOreSet S] → AddMonoid (AddOreLocalization S R) | true |
Std.DTreeMap.Raw.getKey_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} (h' : k ∈ t), t.getKey k h' = k | true |
Lean.Widget.instAppendInteractiveGoals | Lean.Widget.InteractiveGoal | Append Lean.Widget.InteractiveGoals | true |
Std.Internal.List.contains_insertList_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) = true ↔
Std.Internal.List.containsKey k l = true ∨ Std.Internal.List.containsKey k toInsert = true | true |
instInhabitedTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(M : Type u_2) → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Inhabited (TensorAlgebra R M) | true |
_private.Mathlib.Data.TypeVec.0.TypeVec.toSubtype'.match_1.eq_1 | Mathlib.Data.TypeVec | ∀
(motive :
(n : ℕ) →
(α : TypeVec.{u_1} n) →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
(x : Fin2 n) → { x_1 // TypeVec.ofRepeat (p x (TypeVec.prod.mk x x_1.1 x_1.2)) } → Sort u_2)
(n : ℕ) (α : TypeVec.{u_1} (n + 1)) (p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop)) (i : Fin2 n... | true |
List.eraseIdx_eq_take_drop_succ | Init.Data.List.Erase | ∀ {α : Type u_1} (l : List α) (i : ℕ), l.eraseIdx i = List.take i l ++ List.drop (i + 1) l | true |
AntitoneOn._to_dual_cast_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
AntitoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≤ b → f b ≤ f a | false |
_private.Lean.Elab.BuiltinEvalCommand.0.Lean.Elab.Command.mkDeltaInstProj._unsafe_rec | Lean.Elab.BuiltinEvalCommand | Lean.Name → Lean.Name → Lean.Expr → optParam (Option Lean.Expr) none → optParam Bool true → Lean.MetaM Lean.Expr | false |
UniformContinuousConstSMul.mk | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : SMul M X],
(∀ (c : M), UniformContinuous fun x => c • x) → UniformContinuousConstSMul M X | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.unsat_of_encounteredBoth._proof_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {n : ℕ} (assignment : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
(if l.2 = true then Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit l
else Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty) =
Std.Tac... | false |
_private.Lean.Meta.Tactic.Grind.Order.Internalize.0.Lean.Meta.Grind.Order.adaptNat.adaptCnstr.match_1 | Lean.Meta.Tactic.Grind.Order.Internalize | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((rhs' h₂ : Lean.Expr) → motive (rhs', h₂)) → motive __discr | false |
CategoryTheory.MonoidalOpposite.tensorIso | Mathlib.CategoryTheory.Monoidal.Opposite | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategory.tensor Cᴹᵒᵖ ≅
((CategoryTheory.unmopFunctor C).prod (CategoryTheory.unmopFunctor C)).comp
((CategoryTheory.Prod.swap C C).comp
((Category... | true |
Lean.mkBRecOn | Lean.Meta.Constructions.BRecOn | Lean.Name → Lean.MetaM Unit | true |
Lean.Grind.instCommRingUSize._proof_3 | Init.GrindInstances.Ring.UInt | ∀ (i : ℤ) (a : USize), -i • a = -(i • a) | false |
Lean.Parser.Command.docs_to_verso.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | true |
Submodule.ker_subtype | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), p.subtype.ker = ⊥ | true |
OrderEmbedding.locallyFiniteOrder | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [LocallyFiniteOrder β] → α ↪o β → LocallyFiniteOrder α | true |
AddSubsemigroup.mem_inf._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {p p' : AddSubsemigroup M} {x : M}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') | false |
Finset.notMem_mono | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → ∀ {a : α}, a ∉ t → a ∉ s | true |
Quiver.Path.heq_of_cons_eq_cons | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d},
p.cons e = p'.cons e' → p ≍ p' | true |
Lean.Elab.Command.elabReduce._regBuiltin.Lean.Elab.Command.elabReduce_1 | Lean.Elab.BuiltinCommand | IO Unit | false |
Aesop.RuleBuilder.cases | Aesop.Builder.Cases | Aesop.RuleBuilder | true |
UInt32.ofNatLT_bitVecToNat | Init.Data.UInt.Lemmas | ∀ (n : BitVec 32), UInt32.ofNatLT n.toNat ⋯ = { toBitVec := n } | true |
Subarray.foldr | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → (α → β → β) → β → Subarray α → β | true |
NNReal.holderConjugate_comm | Mathlib.Data.Real.ConjExponents | ∀ {p q : NNReal}, p.HolderConjugate q ↔ q.HolderConjugate p | true |
_private.Mathlib.CategoryTheory.Comma.Presheaf.Basic.0.CategoryTheory.OverPresheafAux.MakesOverArrow.map₁._simp_1_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ (α : Type u) (p : α → Prop), (∀ (x : (CategoryTheory.forget (Type u)).obj α), p x) = ∀ (x : α), p x | false |
PartialEquiv.IsImage.restr._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {t : Set β}, Set.RightInvOn (↑e.symm) (↑e) (e.target ∩ t) | false |
_private.Mathlib.Topology.Sequences.0.compactSpace_iff_seqCompactSpace._simp_1_1 | Mathlib.Topology.Sequences | ∀ {X : Type u} [inst : TopologicalSpace X], CompactSpace X = IsCompact Set.univ | false |
Lean.Elab.Tactic.Do.ProofMode.mRefineCore._unsafe_rec | Lean.Elab.Tactic.Do.ProofMode.Refine | Lean.Elab.Tactic.Do.ProofMode.MGoal →
Lean.Parser.Tactic.MRefinePat →
(Lean.Elab.Tactic.Do.ProofMode.MGoal → Lean.TSyntax `Lean.binderIdent → Lean.Elab.Tactic.TacticM Lean.Expr) →
Lean.Elab.Tactic.TacticM Lean.Expr | false |
Bimod.AssociatorBimod.hom._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X... | false |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv._proof_6 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Jᵒᵖ C}
(X : (CategoryTheory.Limits.Cocone F)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Iso.refl
({ obj := fun c => Opposite.op... | false |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right]
{K₁ K₂ :
CategoryTheory.Limits.Fork
(I.fstPiMapOfI... | true |
Prod.le_def | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, x ≤ y ↔ x.1 ≤ y.1 ∧ x.2 ≤ y.2 | true |
IsLocalization.Away.sec.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x x_1 : R)
(e_x : x = x_1) [inst_3 : IsLocalization.Away x S] (s s_1 : S),
s = s_1 → IsLocalization.Away.sec x s = IsLocalization.Away.sec x_1 s_1 | true |
Homotopy.compRight._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i j : ι),
¬c.Rel j i → CategoryTheory.CategoryStruct.comp (h.hom i j) (g.f j) = 0 | false |
zero_mem_tangentConeAt_iff._simp_1 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s : Set E} {x : E}, (0 ∈ tangentConeAt 𝕜 s x) = (x ∈ closure s) | false |
CovariantDerivative.affine_combination | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | {𝕜 : 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} →
... | true |
Nat.gcd_gcd_self_right_left | Init.Data.Nat.Gcd | ∀ (m n : ℕ), m.gcd (m.gcd n) = m.gcd n | true |
Std.DHashMap.Internal.Raw₀.Const.get_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : (↑m₁).WF) (h₂ : (↑m₂).WF) (h : (↑m₁).Equiv ↑m₂) {k : α}
(h' : m₁.contains k = true),
Std.DHashMap.Internal.Raw₀.Const.get m₁ k h' = Std.DHashMa... | true |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X : ProfiniteAddGrp.{u_1}}, T2Space ↑X.toProfinite.toTop | false |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.proveEq._sparseCasesOn_4 | Mathlib.Tactic.Ring.Basic | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
EuclideanGeometry.Sphere.IsDiameter.mk._flat_ctor | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → midpoint ℝ p₁ p₂ = s.center → s.IsDiameter p₁ p₂ | false |
FourierInvModule.mk.noConfusion | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : outParam (Type u_7)} →
{inst : Add E} →
{inst_1 : Add F} →
{inst_2 : SMul R E} →
{inst_3 : SMul R F} →
{P : Sort u} →
{toFourierTransformInv : FourierTransformInv E F} →
{fourierInv_add :
... | false |
hnot_hnot_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢￢￢a = ￢a | true |
SkewMonoidAlgebra.recOn | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : Zero k] →
{motive : SkewMonoidAlgebra k G → Sort u} →
(t : SkewMonoidAlgebra k G) → ((toFinsupp : G →₀ k) → motive { toFinsupp := toFinsupp }) → motive t | false |
Std.DTreeMap.Internal.Impl.Tree.noConfusion | Std.Data.DTreeMap.Internal.Operations | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{size : ℕ} →
{t : Std.DTreeMap.Internal.Impl.Tree α β size} →
{α' : Type u} →
{β' : α' → Type v} →
{size' : ℕ} →
{t' : Std.DTreeMap.Internal.Impl.Tree α' β' size'} →
α = α' → β ≍ ... | false |
Lean.Elab.Deriving.withoutExposeFromCtors | Lean.Elab.Deriving.Util | {α : Type} → Lean.Name → Lean.Elab.Command.CommandElabM α → Lean.Elab.Command.CommandElabM α | true |
_private.Mathlib.Algebra.Category.HopfAlgCat.Basic.0.HopfAlgCat.mk.sizeOf_spec | Mathlib.Algebra.Category.HopfAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : SizeOf R] (carrier : Type v) [instRing : Ring carrier]
[instHopfAlgebra : HopfAlgebra R carrier],
sizeOf { carrier := carrier, instRing := instRing, instHopfAlgebra := instHopfAlgebra } =
1 + sizeOf carrier + sizeOf instRing + sizeOf instHopfAlgebra | true |
le_mul_inv_iff_mul_le._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a b c : α}, (c ≤ a * b⁻¹) = (c * b ≤ a) | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.not_le._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
FractionalIdeal.extendedHomₐ_injective | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A]
[inst_2 : CommRing B] [inst_3 : IsDomain B] [inst_4 : Algebra A B] [inst_5 : Module.IsTorsionFree A B]
[inst_6 : Field K] [inst_7 : Field L] [inst_8 : Algebra A K] [inst_9 : Algebra B L] [inst_10 : IsFractionRing... | true |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
CategoryTheory.Functor C (CategoryTheory.Comon D) → CategoryTheory.Comon (CategoryTheory.Functor C D) | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₄.congr_simp | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₃.HasTensor X₄] [inst_4 : X₂.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj X₃ X₄)]
[inst_5 :
X₁... | true |
vadd_left_cancel_iff._simp_1 | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = g +ᵥ y) = (x = y) | false |
FinPartOrd.instCoeSortType | Mathlib.Order.Category.FinPartOrd | CoeSort FinPartOrd (Type u_1) | true |
List.fixedLengthDigits.congr_simp | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b b_1 : ℕ} (e_b : b = b_1) (hb : 1 < b) (l l_1 : ℕ),
l = l_1 → List.fixedLengthDigits hb l = List.fixedLengthDigits ⋯ l_1 | true |
CategoryTheory.Bicategory.postcomposingCat._proof_4 | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y Z : b ⟶ c} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.toCatHom₂
((CategoryTheory.Bicategory.postcomposing a b c).map (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCa... | false |
Lean.Elab.Tactic.Conv.evalLiftLets | Lean.Elab.Tactic.Conv.Lets | Lean.Elab.Tactic.Tactic | true |
Pi.monotoneCurry | Mathlib.Control.LawfulFix | (α : Type u_1) →
(β : α → Type u_2) →
(γ : (a : α) → β a → Type u_3) →
[inst : (x : α) → (y : β x) → Preorder (γ x y)] →
((x : (a : α) × β a) → γ x.fst x.snd) →o (a : α) → (b : β a) → γ a b | true |
Commute.natCast_mul_self | Mathlib.Data.Nat.Cast.Commute | ∀ {α : Type u_1} [inst : Semiring α] (a : α) (n : ℕ), Commute (↑n * a) a | true |
MeasureTheory.Measure.regular_of_isAddLeftInvariant | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] [SecondCountableTopology G] {μ : MeasureTheory.Measure G}
[MeasureTheory.SigmaFinite μ] [μ.IsAddLeftInvariant] {K : Set G},
IsCompact K → (interior K).Nonempty → μ K ≠ ⊤ → μ.Reg... | true |
ULift.inv.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : Inv α], ULift.inv = { inv := fun f => { down := f.down⁻¹ } } | true |
_private.Mathlib.Analysis.Calculus.DifferentialForm.VectorField.0.extDeriv_apply_vectorField_of_pairwise_commute._simp_1_1 | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f... | false |
Lean.PersistentHashMap.Node.casesOn | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
(t : Lean.PersistentHashMap.Node α β) →
((es : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
motive_1 (Lean.PersistentHashMap.Node.entries es)) →
((ks : Array... | false |
TrivSqZeroExt.addGroupWithOne._proof_5 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroupWithOne R] [inst_1 : AddGroup M] (a : TrivSqZeroExt R M), -a + a = 0 | false |
Aesop.FIFOQueue.casesOn | Aesop.Search.Queue | {motive : Aesop.FIFOQueue → Sort u} →
(t : Aesop.FIFOQueue) → ((goals : Array Aesop.GoalRef) → (pos : ℕ) → motive { goals := goals, pos := pos }) → motive t | false |
_private.Lean.Meta.Basic.0.Lean.Meta.isClassQuick?.match_3 | Lean.Meta.Basic | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | false |
FreeAlgebra.Pre.hasZero | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → Zero (FreeAlgebra.Pre R X) | true |
add_le_add_add_tsub | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}
[AddLeftMono α], a + b ≤ a + c + (b - c) | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2) (it' : Std.Iter β)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.skip it' with
| Std.Iter... | true |
Continuous.of_inv | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [ContinuousInv G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous f⁻¹ → Continuous f | true |
FormalMultilinearSeries.prod.eq_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} {G : Type x} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : Continu... | true |
_private.Aesop.Stats.Basic.0.Aesop.profiling.match_1 | Aesop.Stats.Basic | {α : Type} →
(motive : α × Aesop.Nanos → Sort u_1) →
(__discr : α × Aesop.Nanos) → ((result : α) → (elapsed : Aesop.Nanos) → motive (result, elapsed)) → motive __discr | false |
Multipliable.div | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : CommGroup α] [inst_1 : TopologicalSpace α]
[IsTopologicalGroup α] {f g : β → α}, Multipliable f L → Multipliable g L → Multipliable (fun b => f b / g b) L | true |
LieSubmodule.toSubmodule_eq_bot._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {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 : LieSubmodule R L M), (↑N = ⊥) = (N = ⊥) | false |
LinearEquiv.sumArrowLequivProdArrow_apply_fst | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_5}
{β : Type u_6} (f : α ⊕ β → M) (a : α), ((LinearEquiv.sumArrowLequivProdArrow α β R M) f).1 a = f (Sum.inl a) | true |
_private.Lean.Elab.SetOption.0.Lean.Elab.elabSetOption.match_1 | Lean.Elab.SetOption | (motive : Lean.Syntax → Sort u_1) →
(val : Lean.Syntax) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "true")) →
((info : Lean.SourceInfo) → motive (Lean.Syntax.atom info "false")) → ((x : Lean.Syntax) → motive x) → motive val | false |
SemiRingCat.limitSemiring._proof_22 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt), 1 * a = a | false |
Ideal.Filtration.smul_le | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(self : I.Filtration M) (i : ℕ), I • self.N i ≤ self.N (i + 1) | true |
_private.Lean.Meta.Eqns.0.Lean.Meta.getEqnsFnsRef | Lean.Meta.Eqns | IO.Ref (List Lean.Meta.GetEqnsFn) | true |
CategoryTheory.Limits.kernelCompMono_hom | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) [inst_2 : CategoryTheory.Limits.HasKernel f] [inst_3 : CategoryTheory.Mono g],
(CategoryTheory.Limits.kernelCompMono f g).hom =
CategoryTheory.Limits.kernel.lift f (Ca... | true |
Lean.Parser.Tactic.Conv.occsWildcard | Init.Conv | Lean.ParserDescr | true |
_private.Mathlib.Order.Interval.Finset.Gaps.0.Finset.intervalGapsWithin_fst_le_snd._proof_1_13 | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} (F : Finset (α × α)) {k : ℕ}, ∀ j < k + 1, k - 1 + 1 = k → ¬j - 1 < k → False | false |
Real.sqPartialHomeomorph._proof_4 | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ x ∈ Set.Ioi 0, √x ^ 2 = x | false |
_private.Plausible.Gen.0.Plausible.instReprGenError.repr.match_1 | Plausible.Gen | (motive : Plausible.GenError → Sort u_1) →
(x : Plausible.GenError) → ((a : String) → motive (Plausible.GenError.genError a)) → motive x | false |
MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image | Mathlib.MeasureTheory.Function.Jacobian | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {s : Set E}
{f : E → E} {f' : E → E →L[ℝ] E} [inst_3 : MeasurableSpace E] [BorelSpace E] (μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure],
MeasurableSet s →
(∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) →
Set... | true |
HasDerivWithinAt.neg | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' s x → HasDerivWithinAt (-f) (-f') s x | true |
CStarAlgebra.toCompleteSpace | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : CStarAlgebra A], CompleteSpace A | true |
Finset.recOn | Mathlib.Data.Finset.Defs | {α : Type u_4} →
{motive : Finset α → Sort u} →
(t : Finset α) → ((val : Multiset α) → (nodup : val.Nodup) → motive { val := val, nodup := nodup }) → motive t | false |
IsometryEquiv.toRealLinearIsometryEquivOfMapZero._proof_7 | Mathlib.Analysis.Normed.Affine.MazurUlam | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] (f : E ≃ᵢ F),
Function.RightInverse f.invFun f.toFun | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.