name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AlgebraicClosure.instGroupWithZero._proof_8 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (a : AlgebraicClosure k), AlgebraicClosure.instGroupWithZero._aux_6 k 0 a = 1)
DivInvMonoid.zpow_zero'._autoParam | false |
TensorProduct.quotientTensorQuotientEquiv._proof_9 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N], IsScalarTower R R (TensorProduct R M N) | false |
CategoryTheory.Functor.whiskeringLeft₃ObjObjMap_app | Mathlib.CategoryTheory.Whiskering | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheo... | true |
PolynomialLaw.instZero._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type u_1} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
{S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algebra R S'] (φ : S →ₐ[R] S')... | false |
FirstOrder.Language.isFraisse_finite_linear_order | Mathlib.ModelTheory.Order | FirstOrder.Language.IsFraisse {M | Finite ↑M ∧ ↑M ⊨ FirstOrder.Language.order.linearOrderTheory} | true |
TestFunction.monoCLM._proof_4 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {Ω₁ Ω₂ : TopologicalSpace.Opens E} {n₁ n₂ : ℕ∞}
(K : TopologicalSpace.Compacts E), ↑K ⊆ ↑Ω₁ → n₂ ≤ n₁ ∧ Ω₁ ≤ Ω₂ → ↑K ⊆ ↑Ω₂ | false |
CategoryTheory.Cat.freeMapIdIso | Mathlib.CategoryTheory.Category.Quiv | (V : Type u_1) →
[inst : Quiver V] → CategoryTheory.Cat.freeMap (𝟭q V) ≅ CategoryTheory.Functor.id (CategoryTheory.Paths V) | true |
ULift.addGroup._proof_4 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : AddGroup α] (x x_1 : ULift.{u_1, u_2} α), Equiv.ulift (x - x_1) = Equiv.ulift (x - x_1) | false |
CategoryTheory.Limits.Types.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type u)) → [Small.{u, max u v} F.ColimitType] → CategoryTheory.Limits.Cocone F | true |
Nat.recOnPrimePow._proof_2 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), Nat.Prime (k + 2).minFac | false |
Lean.Meta.instInhabitedCaseArraySizesSubgoal.default | Lean.Meta.Match.CaseArraySizes | Lean.Meta.CaseArraySizesSubgoal | true |
FiniteField.instFieldExtension._proof_68 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] (n : ℕ) [inst_2 : CharP k p],
autoParam (∀ (q : ℚ≥0) (a : FiniteField.Extension k p n), FiniteField.instFieldExtension._aux_66 k p n q a = ↑q * a)
DivisionRing.nnqsmul_def._autoParam | false |
CategoryTheory.Limits.SequentialProduct.functorObj_eq_neg | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ {C : Type u_1} {M N : ℕ → C} {n m : ℕ}, ¬m < n → (fun i => if x : i < n then M i else N i) m = N m | true |
AddAction.vadd_mem_fixedBy_iff_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a : α} {g : G},
g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g | true |
Lean.Parser.Term.binrel._regBuiltin.Lean.Parser.Term.binrel_1 | Lean.Parser.Term | IO Unit | false |
instCompleteLinearOrderWithBotENat._proof_12 | Mathlib.Data.ENat.Lattice | ∀ (a : WithBot ℕ∞), ⊤ \ a = ￢a | false |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_apply_zero_of_even._simp_1_2 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
_private.Plausible.Gen.0.Plausible.Gen.runUntil.repeatGen.match_1 | Plausible.Gen | (motive : Option ℕ → Sort u_1) →
(attempts : Option ℕ) → (Unit → motive (some 0)) → ((x : Option ℕ) → motive x) → motive attempts | false |
LieModule.Weight.mk | Mathlib.Algebra.Lie.Weights.Basic | {R : Type u_2} →
{L : Type u_3} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | true |
MeasureTheory.FiniteMeasure.restrict_apply | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω) (A : Set Ω) {s : Set Ω},
MeasurableSet s → (μ.restrict A) s = μ (s ∩ A) | true |
Rep.FiniteCyclicGroup.groupCohomologyIsoEven._proof_4 | Mathlib.RepresentationTheory.Homological.GroupCohomology.FiniteCyclic | ∀ (i : ℕ) [h₀ : NeZero i], Even i → (ComplexShape.up ℕ).Rel ((ComplexShape.up ℕ).prev i) i | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Countable.0.CategoryTheory.Limits.IsFiltered.sequentialFunctor_final._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {α : Type u} {R : α → α → Prop} (a : α), List.IsChain R [a] = True | false |
NumberField.mixedEmbedding.negAt_apply_isComplex | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }} (x : NumberField.mixedEmbedding.mixedSpace K)
(w : { w // w.IsComplex }), ((NumberField.mixedEmbedding.negAt s) x).2 w = x.2 w | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_sigma0_eq_sum_div._proof_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (N x : ℕ), x ∈ Finset.Ioc 0 N → N / x = if x = 0 then 0 else N / x | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqc.go._unsafe_rec | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr | false |
LocalSubring.instPartialOrder._proof_2 | Mathlib.RingTheory.LocalRing.LocalSubring | ∀ {R : Type u_1} [inst : CommRing R], SubringClass (Subring R) R | false |
Lean.Compiler.LCNF.MonadFVarSubstState.recOn | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.MonadFVarSubstState m pu → Sort u} →
(t : Lean.Compiler.LCNF.MonadFVarSubstState m pu) →
((modifySubst : (Lean.Compiler.LCNF.FVarSubst pu → Lean.Compiler.LCNF.FVarSubst pu) → m Unit) →
motive { modifySubs... | false |
PadicComplex.instRankOneNNRealV._proof_6 | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], CompletableTopField (PadicAlgCl p) | false |
_private.Mathlib.Data.Finset.Image.0.Finset.coe_map_subset_range._proof_1_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_2} {β : Type u_1} (f : α ↪ β) (s : Finset α), ↑(Finset.map f s) ⊆ Set.range ⇑f | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform.0.EisensteinSeries.G2_slash_action._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
List.Vector.ofFn | Mathlib.Data.Vector.Defs | {α : Type u_1} → {n : ℕ} → (Fin n → α) → List.Vector α n | true |
_private.Mathlib.SetTheory.Cardinal.Pigeonhole.0.Cardinal.le_range_of_union_finset_eq_univ._simp_1_1 | Mathlib.SetTheory.Cardinal.Pigeonhole | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Localization.mkHom_surjective | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Function.Surjective ⇑Localization.mkHom | true |
MonoidHom.toAdditive._proof_5 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_2} {β : Type u_1} [inst : MulOneClass α] [inst_1 : MulOneClass β] (f : Additive α →+ Additive β), f 0 = 0 | false |
AddGroupSeminormClass.toSeminormedAddGroup.congr_simp | Mathlib.Analysis.Normed.Order.Hom.Ultra | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f f_1 : F), f = f_1 → AddGroupSeminormClass.toSeminormedAddGroup f = AddGroupSeminormClass.toSeminormedAddGroup f_1 | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaOdd.0.HurwitzZeta.hasSum_int_completedSinZeta._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, |↑a| = ↑|a| | false |
instFinitePresentation | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R], Module.FinitePresentation R R | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusion | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {P : Sort u} →
{t t' : Lean.Meta.Simp.Arith.Int.ToLinear.State} →
t = t' → Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusionType P t t' | false |
Std.TreeSet.get?_eq_some_iff | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k k' : α},
t.get? k = some k' ↔ ∃ (h : k ∈ t), t.get k h = k' | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c | false |
FirstOrder.Language.LHom.realize_onBoundedFormula | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'}
[inst_1 : L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ} (ψ : L.BoundedFormula α n) {v : α → M}
{xs : Fin n → M}, (φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs | true |
Submodule.singleton_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (a : A)
(M : Submodule R A), Set.up {a} • M = Submodule.map (LinearMap.mulLeft R a) M | true |
intervalIntegral.intervalIntegrable_log'._simp_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {a b : ℝ}, IntervalIntegrable Real.log MeasureTheory.volume a b = True | false |
Lean.Server.FileWorker.SemanticTokensState.recOn | Lean.Server.FileWorker.SemanticHighlighting | {motive : Lean.Server.FileWorker.SemanticTokensState → Sort u} →
(t : Lean.Server.FileWorker.SemanticTokensState) → motive { } → motive t | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne.match_1.congr_eq_1._sparseCasesOn_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < w - target.distance % w → idx - (w - target.distance % w) < w | false |
Algebra.TensorProduct.basis_apply | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} {A : Type u_2} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] (b : Module.Basis ι R M) (i : ι),
(Algebra.TensorProduct.basis A b) i = 1 ⊗ₜ[R] b i | true |
Finset.surjOn_of_injOn_of_card_le | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (f : α → β),
Set.MapsTo f ↑s ↑t → Set.InjOn f ↑s → t.card ≤ s.card → Set.SurjOn f ↑s ↑t | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.not_cliqueFree_of_isTuranMaximal._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Std.ExtDTreeMap.getKey!_erase_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α}, (t.erase k).getKey! k = default | true |
CategoryTheory.Bicategory.Adj.Hom₂.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
{τl : α.l ⟶ β.l} {τr : β.r ⟶ α.r}
{conjugateEquiv_τl :
autoParam ((CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) τl = τr)
CategoryTheory.Bicategory.Adj.Hom₂.conjugateEquiv_τl._autoParam}
{τl... | true |
CategoryTheory.OplaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.OplaxFunctor B C) | false |
List.foldl_nil | Init.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → α} {b : α}, List.foldl f b [] = b | true |
DomMulAct.smul_aeeqFun_const | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : SMul M α] [inst_3 : MeasurableConstSMul M α]
[inst_4 : MeasureTheory.SMulInvariantMeasure M α μ] (c : Mᵈᵐᵃ) (b : β),
c • MeasureTheory.AEEqFun.const α b = MeasureTheory.A... | true |
ListSlice.toArray_toList | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, (Std.Slice.toList xs).toArray = Std.Slice.toArray xs | true |
CategoryTheory.Abelian.SpectralObject.E._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_projective.match_1_1 | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id) → Prop)
(x : ∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id),
(∀ (_n : ℕ) (_f : (Fin _n → R) ... | false |
CategoryTheory.Bicategory.toNatTrans_conjugateEquiv | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C D : CategoryTheory.Cat} {L₁ L₂ : C ⟶ D} {R₁ R₂ : D ⟶ C} (adj₁ : CategoryTheory.Bicategory.Adjunction L₁ R₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction L₂ R₂) (f : L₂ ⟶ L₁),
((CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₂) f).toNatTrans =
(CategoryTheory.conjugateEquiv (CategoryTheory.Adjunction.ofCa... | true |
SheafOfModules.Presentation.mapRelations._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCo... | false |
Con.subgroup._proof_3 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (c : Con G), c 1 1 | false |
Std.Internal.List.getKey?_minKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {fallback : α},
Std.Internal.List.getKey? (Std.Internal.List.minKeyD l fallback) l = some (Std.Internal.List.mi... | true |
Subgroup.instMulActionLeftTransversal | Mathlib.GroupTheory.Complement | {G : Type u_1} →
[inst : Group G] →
{H : Subgroup G} →
{F : Type u_2} →
[inst_1 : Group F] → [inst_2 : MulAction F G] → [MulAction.QuotientAction F H] → MulAction F H.LeftTransversal | true |
Lean.Lsp.CancelParams.mk._flat_ctor | Lean.Data.Lsp.CancelParams | Lean.JsonRpc.RequestID → Lean.Lsp.CancelParams | false |
AddHom.srangeRestrict.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Add M] {N : Type u_5} [inst_1 : Add N] (f : M →ₙ+ N),
f.srangeRestrict = f.codRestrict f.srange ⋯ | true |
Lean.Grind.AC.Context.noConfusionType | Init.Grind.AC | Sort u_1 → {α : Sort u} → Lean.Grind.AC.Context α → {α' : Sort u} → Lean.Grind.AC.Context α' → Sort u_1 | false |
Decidable.and_iff_not_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a] [Decidable b], a ∧ b ↔ ¬(¬a ∨ ¬b) | true |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.ctorIdx | Init.Data.String.Pattern.Basic | {ρ : Type} → {pat : ρ} → {s : String.Slice} → String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s → ℕ | false |
Set.piecewise | Mathlib.Logic.Function.Basic | {α : Type u} →
{β : α → Sort v} → (s : Set α) → ((i : α) → β i) → ((i : α) → β i) → [(j : α) → Decidable (j ∈ s)] → (i : α) → β i | true |
Lean.Elab.Term.Do.Code._sizeOf_5_eq | Lean.Elab.Do.Legacy | ∀ (x : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)), Lean.Elab.Term.Do.Code._sizeOf_5 x = sizeOf x | false |
ArithmeticFunction.instCommRing._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommRing R] (a b : ArithmeticFunction R), a - b = a + -b | false |
Std.ExtHashMap.mem_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → γ} {k : α}, k ∈ Std.ExtHashMap.map f m ↔ k ∈ m | true |
ULift.algebra._proof_4 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x y : R),
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun (x + y) =
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun x +
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap ... | false |
CategoryTheory.Functor.ReflectsMonomorphisms | Mathlib.CategoryTheory.Functor.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | true |
_private.Init.Data.Array.Attach.0.Array.attachWithImpl | Init.Data.Array.Attach | {α : Type u_1} → (xs : Array α) → (P : α → Prop) → (∀ x ∈ xs, P x) → Array { x // P x } | true |
Valuation.RankOne.mk | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → [toRankLeOne : v.RankLeOne] → [toIsNontrivial : v.IsNontrivial] → v.RankOne | true |
Lean.Compiler.LCNF.Closure.State.mk.injEq | Lean.Compiler.LCNF.Closure | ∀ (visited : Lean.FVarIdHashSet) (params : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(decls : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)) (visited_1 : Lean.FVarIdHashSet)
(params_1 : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(decls_1 : Array (L... | true |
ZeroAtInftyContinuousMap.instNonUnitalCommSemiring._proof_6 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalCommSemiring β] [inst_3 : IsTopologicalSemiring β] (f g : ZeroAtInftyContinuousMap α β),
⇑(f * g) = ⇑f * ⇑g | false |
IsCompactOpenCovered.empty | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {f : (i : ι) → X i → S} [inst : (i : ι) → TopologicalSpace (X i)],
IsCompactOpenCovered f ∅ | true |
Real.cauchy_intCast | Mathlib.Data.Real.Basic | ∀ (z : ℤ), (↑z).cauchy = ↑z | true |
map_inv₀ | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀), f a⁻¹ = (f a)⁻¹ | true |
IsLocalization.Away.mapₐ.congr_simp | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_5} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {B : Type u_6}
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (Aₚ : Type u_7) [inst_5 : CommSemiring Aₚ] [inst_6 : Algebra A Aₚ]
[inst_7 : Algebra R Aₚ] [inst_8 : IsScalarTower R A Aₚ] (Bₚ : Type u_8) [inst_9 ... | true |
Int16.sub_right_inj._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16} (c : Int16), (c - a = c - b) = (a = b) | false |
RootPairing.rootSpan_eq_top_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Field R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[P.IsAnisotropic], P.rootSpan R = ⊤ ↔ P.corootSpan R = ⊤ | true |
Lean.Meta.FunInd.Collector.saveFunInd | Lean.Meta.Tactic.FunIndCollect | Lean.Expr → Lean.Meta.FunIndInfo → Array Lean.Expr → Lean.Meta.FunInd.Collector.M Unit | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_37 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w : α),
[].length + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
[].length < (List.filter (fun x => decide (x = w)) []).length | false |
CharP.subsemiring | Mathlib.Algebra.CharP.Subring | ∀ (R : Type u) [inst : Semiring R] (p : ℕ) [CharP R p] (S : Subsemiring R), CharP (↥S) p | true |
_private.Mathlib.RingTheory.ChainOfDivisors.0.pow_image_of_prime_by_factor_orderIso_dvd._simp_1_1 | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : Monoid M], 1 = ⊥ | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_316 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.finsetCongr_piAntidiag_eq_antidiag._simp_1_1 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e y = x) = (y = e.symm x) | false |
Std.HashMap.getElem!_alter_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
[inst : Inhabited β] {f : Option β → Option β}, (m.alter k f)[k]! = (f m[k]?).get! | true |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{f₁... | true |
_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo.rec | Lean.Meta.MethodSpecs | {motive : Lean.MethodSpecsInfo✝ → Sort u} →
((clsName : Lean.Name) →
(privateSpecs : Bool) →
(fieldImpls : Array (Lean.Name × Lean.Name)) →
(thms : Array Lean.MethodSpecTheorem✝) →
motive { clsName := clsName, privateSpecs := privateSpecs, fieldImpls := fieldImpls, thms := thms }) ... | false |
Pi.nonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (a b : (i : I) → f i),
a + b = b + a | false |
CategoryTheory.Limits.Multiequalizer.lift_ι_assoc | 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.HasMultiequalizer I] (W : C)
(k : (a : J.L) → W ⟶ I.left a)
(h :
∀ (b : J.R),
CategoryTheory.CategoryStruct.comp (k (J.fs... | true |
Array.ne_push_self._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (xs = xs.push a) = False | false |
Set.add_univ | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s : Set α}, s.Nonempty → s + Set.univ = Set.univ | true |
ContinuousMap.compAddMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : AddZeroClass γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | false |
Mathlib.Tactic.Bound._aux_Mathlib_Tactic_Bound_Attribute___macroRules_Mathlib_Tactic_Bound_attrBound_forward_1 | Mathlib.Tactic.Bound.Attribute | Lean.Macro | false |
Lean.Doc.Block.dl | Lean.DocString.Types | {i : Type u} → {b : Type v} → Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Lean.Doc.Block i b | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.