name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Array.forIn_map | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} {init : γ} [inst : Monad m] [LawfulMonad m]
{xs : Array α} {g : α → β} {f : β → γ → m (ForInStep γ)},
forIn (Array.map g xs) init f = forIn xs init fun a y => f (g a) y | true |
_private.Mathlib.Data.Set.NAry.0.Set.image2_distrib_subset_left._proof_1_1 | Mathlib.Data.Set.NAry | ∀ {α : Type u_2} {β : Type u_4} {β' : Type u_6} {γ : Type u_5} {γ' : Type u_7} {δ : Type u_3} {ε : Type u_1} {s : Set α}
{t : Set β} {u : Set γ} {f : α → δ → ε} {g : β → γ → δ} {f₁ : α → β → β'} {f₂ : α → γ → γ'} {g' : β' → γ' → ε},
(∀ (a : α) (b : β) (c : γ), f a (g b c) = g' (f₁ a b) (f₂ a c)) →
Set.image2 f ... | false |
Finset.insert_nonempty._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (insert a s).Nonempty = True | false |
ZNum.addCommGroup._proof_2 | Mathlib.Data.Num.ZNum | ∀ (a : ZNum), zsmulRec nsmulRec 0 a = 0 | false |
Lean.Meta.ExtractLets.State.noConfusionType | Lean.Meta.Tactic.Lets | Sort u → Lean.Meta.ExtractLets.State → Lean.Meta.ExtractLets.State → Sort u | false |
List.zipWithM.loop.eq_def | Init.Data.List.Monadic | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) (x : List α)
(x_1 : List β) (x_2 : Array γ),
List.zipWithM.loop f x x_1 x_2 =
match x, x_1, x_2 with
| a :: as, b :: bs, acc => do
let __do_lift ← f a b
List.zipWithM.loop f as bs (acc.push __do_lif... | true |
Finset.card_le_card_mul_left_of_injective | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α} {a : α},
a ∈ s → (Function.Injective fun x => a * x) → t.card ≤ (s * t).card | true |
Algebra.Presentation.instCommRingCore._proof_67 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ} (a : P.Core), -a + a = 0 | false |
AddMonoidAlgebra.modOf_add_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G]
(x : AddMonoidAlgebra k G) (g : G), x.modOf g + AddMonoidAlgebra.of' k G g * x.divOf g = x | true |
List.findFinIdx?_singleton | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {p : α → Bool}, List.findFinIdx? p [a] = if p a = true then some ⟨0, ⋯⟩ else none | true |
DirectLimit.Ring.of._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | false |
MeasureTheory.measureReal_nonneg._simp_1 | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, (0 ≤ μ.real s) = True | false |
Ideal.ramificationIdx_spec | Mathlib.NumberTheory.RamificationInertia.Ramification | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R} {P : Ideal S}
{n : ℕ}, Ideal.map (algebraMap R S) p ≤ P ^ n → ¬Ideal.map (algebraMap R S) p ≤ P ^ (n + 1) → p.ramificationIdx P = n | true |
iSup₂_le_iSup | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] (κ : ι → Sort u_8) (f : ι → α), ⨆ i, ⨆ x, f i ≤ ⨆ i, f i | true |
AlgebraicClosure.isAlgebraic | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u) [inst : Field k], Algebra.IsAlgebraic k (AlgebraicClosure k) | true |
_private.Lean.Meta.Tactic.Grind.LawfulEqCmp.0.Lean.Meta.Grind.getLawfulEqCmpThm?.go?.match_6 | Lean.Meta.Tactic.Grind.LawfulEqCmp | (motive : Lean.Expr → Sort u_1) →
(__discr : Lean.Expr) →
((binderName : Lean.Name) →
(α' b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName α' b binderInfo)) →
((x : Lean.Expr) → motive x) → motive __discr | false |
DirectSum.instLieRingSubtypeMemSubmodule._proof_2 | Mathlib.Algebra.Lie.Graded | ∀ {ι : Type u_1} {R : Type u_3} {L : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid ι] [inst_2 : CommRing R]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ℒ : ι → Submodule R L) [inst_5 : GradedLieAlgebra ℒ]
(x x_1 x_2 : DirectSum ι fun i => ↥(ℒ i)),
(DirectSum.decomposeLinearEquiv ℒ)
⁅(DirectSu... | false |
Quantale.mul_bot | Mathlib.Algebra.Order.Quantale | ∀ {α : Type u_3} [inst : Semigroup α] [inst_1 : CompleteLattice α] [IsQuantale α] {x : α}, x * ⊥ = ⊥ | true |
WeierstrassCurve.Jacobian.negAddY_of_Z_eq_zero_right | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation Q → Q 2 = 0 → W'.negAddY P Q = (-(Q 0 * P 2)) ^ 3 * W'.negY P | true |
Option.le.eq_3 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (val : α), Option.le r (some val) none = False | true |
CategoryTheory.Bimon.trivialTo | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (A : CategoryTheory.Bimon C) → CategoryTheory.Bimon.trivial C ⟶ A | true |
Finsupp.sum_add_index | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : DecidableEq α] [inst_1 : AddZeroClass M]
[inst_2 : AddCommMonoid N] {f g : α →₀ M} {h : α → M → N},
(∀ a ∈ f.support ∪ g.support, h a 0 = 0) →
(∀ a ∈ f.support ∪ g.support, ∀ (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ + h a b₂) → (f + g).sum h = f.sum h + g.sum h | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take_drop._proof_1_3 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {s : Stream'.Seq α} {n m : ℕ} (i : ℕ),
m + i + 1 ≤ (Stream'.Seq.take n s).length → m + i < (Stream'.Seq.take n s).length | false |
_private.Init.Data.Array.BasicAux.0.PSigma.casesOn._arg_pusher | Init.Data.Array.BasicAux | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | false |
tendsto_bdd_div_atTop_nhds_zero | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderTopology 𝕜] {l : Filter α} {f g : α → 𝕜} {b B : 𝕜},
(∀ᶠ (x : α) in l, b ≤ f x) →
(∀ᶠ (x : α) in l, f x ≤ B) → Filter.Tendsto g l Filter.atTop → Filter.Tendsto (fun x => f... | true |
Asymptotics.IsBigO.mul_isLittleO | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] {S : Type u_17} [inst_1 : NormedRing S] [NormMulClass S]
{l : Filter α} {f₁ f₂ : α → R} {g₁ g₂ : α → S},
f₁ =O[l] g₁ → f₂ =o[l] g₂ → (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x | true |
SheafOfModules.mk.sizeOf_spec | Mathlib.Algebra.Category.ModuleCat.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : SizeOf C] (val : PresheafOfModules R.obj)
(isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf), sizeOf { val := val, isSheaf := isSheaf } = 1 + sizeOf val | true |
CoheytingAlgebra.toOrderTop | Mathlib.Order.Heyting.Basic | {α : Type u_4} → [self : CoheytingAlgebra α] → OrderTop α | true |
Lean.Parser.Term.logNamedErrorMacro._regBuiltin.Lean.Parser.Term.logNamedErrorMacro.docString_3 | Lean.Parser.Term | IO Unit | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.1956376046._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.1956376046._hygCtx._hyg.1.noConfusionType P t t' | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr.0.Lean.Meta.Grind.Arith.Cutsat.DvdCnstr.assert.match_6 | Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr | (motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u_1) →
(x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
((c' : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive (some c')) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive x) → motive x | false |
Lean.Language.Lean.instToSnapshotTreeCommandResultSnapshot | Lean.Language.Lean.Types | Lean.Language.ToSnapshotTree Lean.Language.Lean.CommandResultSnapshot | true |
RatFunc.isCoprime_num_denom | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] (x : RatFunc K), IsCoprime x.num x.denom | true |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.matrix_eq._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)],
(G.neighborSet v).toFinset = G.neighborFinset v | false |
SeminormClass.mk | Mathlib.Analysis.Seminorm | ∀ {F : Type u_12} {𝕜 : outParam (Type u_13)} {E : outParam (Type u_14)} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E]
[inst_2 : SMul 𝕜 E] [inst_3 : FunLike F E ℝ] [toAddGroupSeminormClass : AddGroupSeminormClass F E ℝ],
(∀ (f : F) (a : 𝕜) (x : E), f (a • x) = ‖a‖ * f x) → SeminormClass F 𝕜 E | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isLinearSet_iff_exists_matrix.match_1_1 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} {s : Set (ι → ℕ)} (v : ι → ℕ) (n : ℕ) (motive : (∃ f, s = v +ᵥ Set.range ⇑f) → Prop)
(x : ∃ f, s = v +ᵥ Set.range ⇑f), (∀ (f : (Fin n → ℕ) →+ ι → ℕ) (hf : s = v +ᵥ Set.range ⇑f), motive ⋯) → motive x | false |
AddCon.comap_rel._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] {f : M → N} (H : ∀ (x y : M), f (x + y) = f x + f y)
{c : AddCon N} {x y : M}, (AddCon.comap f H c) x y = c (f x) (f y) | false |
CategoryTheory.Functor.PreservesZeroMorphisms.recOn | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
{F : CategoryTheory.Functor C D} →
... | false |
Affine.Simplex.eq_centroid_iff_sum_vsub_eq_zero | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} [CharZero k] {s : Affine.Simplex k P n} {p : P},
p = s.centroid ↔ ∑ i, (s.points i -ᵥ p) = 0 | true |
Vector.set_eq_push_extract_append_extract | Init.Data.Vector.Extract | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} (h : i < n) {a : α},
xs.set i a h = Vector.cast ⋯ ((xs.extract 0 i).push a ++ xs.extract (i + 1)) | true |
TendstoUniformlyOn.tendsto_comp | Mathlib.Topology.UniformSpace.UniformApproximation | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {x : α} {p : Filter ι} {g : ι → α},
TendstoUniformlyOn F f p s →
ContinuousWithinAt f s x → Filter.Tendsto g p (nhdsWithin x s) → Filter.Tendsto (fun n => F n (g n)) p (nh... | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_derivedLits._proof_1_27 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (rupHints : Array ℕ),
(f.performRupCheck rupHints).1.assignments.size = n →
∀ (derivedLits : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(derivedLits_arr : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin... | false |
NumberField.Units.dirichletUnitTheorem.seq.eq_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (w₁ : NumberField.InfinitePlace K) {B : ℕ}
(hB : NumberField.mixedEmbedding.minkowskiBound K 1 < ↑(NumberField.mixedEmbedding.convexBodyLTFactor K) * ↑B)
(n : ℕ), NumberField.Units.dirichletUnitTheorem.seq K w₁ hB n.succ = ⟨⋯.choose, ⋯⟩ | true |
CategoryTheory.Bicategory.InducedBicategory.bicategory_rightUnitor_inv_hom | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b : CategoryTheory.Bicategory.InducedBicategory C F} (x : a ⟶ b),
(CategoryTheory.Bicategory.rightUnitor x).inv.hom = (CategoryTheory.Bicategory.rightUnitor x.hom).inv | true |
Subgroup.rank_commutator_le_card | Mathlib.GroupTheory.Commutator.Finite | ∀ (G : Type u_1) [inst : Group G] [inst_1 : Finite ↑(commutatorSet G)],
Group.rank ↥(commutator G) ≤ Nat.card ↑(commutatorSet G) | true |
_private.Mathlib.RingTheory.Ideal.Maps.0.Module.annihilator_prod._simp_1_6 | Mathlib.RingTheory.Ideal.Maps | ∀ {α : Sort u_1} [Nonempty α] (p : α → Prop) (q : Prop), ((∀ (x : α), p x) ∧ q) = ∀ (x : α), p x ∧ q | false |
Lean.MessageDataContext.ctorIdx | Lean.Message | Lean.MessageDataContext → ℕ | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory.0.CategoryTheory.Triangulated.AbelianSubcategory.mono_ιK._simp_1_3 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
Cardinal.toNat_eq_one | Mathlib.SetTheory.Cardinal.ToNat | ∀ {c : Cardinal.{u}}, Cardinal.toNat c = 1 ↔ c = 1 | true |
_private.Init.Data.UInt.Bitwise.0.USize.shiftLeft_add._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | false |
Zsqrtd.im_star | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (z : ℤ√d), (star z).im = -z.im | true |
MeasurableSet.Subtype.instBooleanAlgebra._proof_2 | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] {x y : Subtype MeasurableSet}, ↑x ≤ ↑y ↔ ↑x ≤ ↑y | false |
MulAction.ctorIdx | Mathlib.Algebra.Group.Action.Defs | {α : Type u_9} → {β : Type u_10} → {inst : Monoid α} → MulAction α β → ℕ | false |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.isLittleO_exp_comp_exp_comp._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ (a : Prop), (False → a) = True | false |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Icc_subset_Ico_iff.match_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α} (motive : a₂ ≤ a₁ ∧ b₁ < b₂ → Prop) (x : a₂ ≤ a₁ ∧ b₁ < b₂),
(∀ (h : a₂ ≤ a₁) (h' : b₁ < b₂), motive ⋯) → motive x | false |
Option.map_id_apply | Init.Data.Option.Lemmas | ∀ {α : Type u} {x : Option α}, Option.map id x = x | true |
HopfAlgebra.mk.noConfusion | Mathlib.RingTheory.HopfAlgebra.Basic | {R : Type u} →
{A : Type v} →
{inst : CommSemiring R} →
{inst_1 : Semiring A} →
{P : Sort u_1} →
{toHopfAlgebraStruct : HopfAlgebraStruct R A} →
{mul_antipode_rTensor_comul :
LinearMap.mul' R A ∘ₗ LinearMap.rTensor A (HopfAlgebraStruct.antipode R) ∘ₗ CoalgebraSt... | false |
Subsemiring.centralizer._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] (s : Set R) {a b : R},
a ∈ (Submonoid.centralizer s).carrier →
b ∈ (Submonoid.centralizer s).carrier → a * b ∈ (Submonoid.centralizer s).carrier | false |
Lean.FuzzyMatching.fuzzyMatchScoreWithThreshold? | Lean.Data.FuzzyMatching | String → String → optParam Float 0.1 → Option Float | true |
Part.eq_none_iff' | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α}, o = Part.none ↔ ¬o.Dom | true |
Vector.getElem_extract | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {as : Vector α n} {start stop : ℕ} (h : i < min stop n - start),
(as.extract start stop)[i] = as[start + i] | true |
CategoryTheory.PreOneHypercover.Hom.ext'._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} {f g : E.Hom F}, f.s₀ = g.s₀ → ∀ (i : E.I₀), g.s₀ i = f.s₀ i | false |
groupHomology.mapShortComplexH1_id_comp | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B C : Rep.{u, u, u} k G} (φ : A ⟶ B) (ψ : B ⟶ C),
groupHomology.mapShortComplexH1 (MonoidHom.id G) (CategoryTheory.CategoryStruct.comp φ ψ) =
CategoryTheory.CategoryStruct.comp (groupHomology.mapShortComplexH1 (MonoidHom.id G) φ)
(groupHomology.mapS... | true |
CoeTC.mk._flat_ctor | Init.Coe | {α : Sort u} → {β : Sort v} → (α → β) → CoeTC α β | false |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.Affine.Simplex.sum_pointsWithCircumcenter._simp_1_1 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | false |
Nat.sub | Init.Prelude | ℕ → ℕ → ℕ | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getBoolLit._sparseCasesOn_2 | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Differentiable.div_const | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c : 𝕜 → 𝕜'}, Differentiable 𝕜 c → ∀ (d : 𝕜'), Differentiable 𝕜 fun x => c x / d | true |
AlgHom.IsArithFrobAt.restrict | Mathlib.RingTheory.Frobenius | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{φ : S →ₐ[R] S} → {Q : Ideal S} → φ.IsArithFrobAt Q → S ⧸ Q →ₐ[R ⧸ Ideal.under R Q] S ⧸ Q | true |
MeasureTheory.FiniteMeasure.instMeasurableSpace._proof_3 | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω], MeasureTheory.FiniteMeasure.instMeasurableSpace._aux_1 ∅ | false |
Std.Iterators.Types.DropWhile.instIterator.match_3 | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] →
{P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} →
(it : Std.IterM m β) →
(motive : it.internalState.inner.Step → Sort u_3) →
(x : it.internalState.inner.Step... | false |
DistribMulAction.toAddAut._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Basic | ∀ (G : Type u_2) (A : Type u_1) [inst : Group G] [inst_1 : AddMonoid A] [inst_2 : DistribMulAction G A] (x x_1 : G),
DistribMulAction.toAddEquiv A (x * x_1) = DistribMulAction.toAddEquiv A x * DistribMulAction.toAddEquiv A x_1 | false |
ProperVAdd.isProperMap_vadd_pair_set | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} {X : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G X] [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace X] [ProperVAdd G X] {t : Set X}, IsProperMap fun gx => (gx.1 +ᵥ ↑gx.2, gx.2) | true |
Cardinal.IsRegular.casesOn | Mathlib.SetTheory.Cardinal.Regular | {c : Cardinal.{u_1}} →
{motive : c.IsRegular → Sort u} →
(t : c.IsRegular) → ((aleph0_le : Cardinal.aleph0 ≤ c) → (le_cof_ord : c ≤ c.ord.cof) → motive ⋯) → motive t | false |
AlgebraicGeometry.Scheme.instIsPreimmersionMapResidue | Mathlib.AlgebraicGeometry.ResidueField | ∀ {X : AlgebraicGeometry.Scheme} (x : ↥X), AlgebraicGeometry.IsPreimmersion (AlgebraicGeometry.Spec.map (X.residue x)) | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofStr._simp_2 | Init.Data.String.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | false |
String.Pos.sliceTo | Init.Data.String.Basic | {s : String} → (p₀ pos : s.Pos) → pos ≤ p₀ → (s.sliceTo p₀).Pos | true |
_private.Mathlib.Topology.Compactification.StoneCech.0.Ultrafilter.tendsto_pure_self._simp_1_1 | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} {β : Type v} {m : α → β} {f : Ultrafilter α} {s : Set β}, (s ∈ Ultrafilter.map m f) = (m ⁻¹' s ∈ f) | false |
NonUnitalStarAlgHom.nnnorm_apply_le | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {F : Type u_1} {A : Type u_2} {B : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : NonUnitalCStarAlgebra B]
[inst_2 : FunLike F A B] [NonUnitalAlgHomClass F ℂ A B] [StarHomClass F A B] (φ : F) (a : A), ‖φ a‖₊ ≤ ‖a‖₊ | true |
Lean.Meta.Sym.ProofInstInfo | Lean.Meta.Sym.SymM | Type | true |
CategoryTheory.Pairwise.coconeIsColimit._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} {α : Type u_2} (U : ι → α) [inst : CompleteLattice α]
(s : CategoryTheory.Limits.Cocone (CategoryTheory.Pairwise.diagram U)) (j : CategoryTheory.Pairwise ι),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pairwise.cocone U).ι.app j) (CategoryTheory.homOfLE ⋯) = s.ι.app j | false |
TopHom.instLattice._proof_2 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Top α] [inst_1 : Lattice β] [inst_2 : OrderTop β] {x y : TopHom α β},
⇑x ≤ ⇑y ↔ ⇑x ≤ ⇑y | false |
_private.Mathlib.Topology.CWComplex.Classical.Finite.0.Topology.RelCWComplex.finite_cells_of_finite.match_1_1 | Mathlib.Topology.CWComplex.Classical.Finite | {X : Type u_1} →
[inst : TopologicalSpace X] →
{C D : Set X} →
[inst_1 : Topology.RelCWComplex C D] →
(n : ℕ) →
(motive : (m : { m // m < n }) × Topology.RelCWComplex.cell C ↑m → Sort u_2) →
(x : (m : { m // m < n }) × Topology.RelCWComplex.cell C ↑m) →
((m : { m ... | false |
Zsqrtd.decidableNonnegg | Mathlib.NumberTheory.Zsqrtd.Basic | (c d : ℕ) → DecidableRel (Zsqrtd.Nonnegg c d) | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenex.match_1.eq_3 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x l : ℕ)
(R : L.Relations l) (ts : Fin l → L.Term (α ⊕ Fin x))
(h_1 : (x : ℕ) → motive x FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.Bounded... | true |
Lean.Elab.Term.elabByTactic._regBuiltin.Lean.Elab.Term.elabByTactic.declRange_3 | Lean.Elab.BuiltinTerm | IO Unit | false |
UpperSet.iciSupHom | Mathlib.Order.UpperLower.Hom | {α : Type u_1} → [inst : SemilatticeSup α] → SupHom α (UpperSet α) | true |
MeasureTheory.AECover.biInter_Ici_aecover | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [Countable ι] [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : Preorder ι] {φ : ι → Set α},
MeasureTheory.AECover μ Filter.atTop φ → MeasureTheory.AECover μ Filter.atTop fun n => ⋂ k ∈ Set.Ici n, φ k | true |
WeierstrassCurve.Jacobian.negAddY_of_X_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q →
P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 → W'.negAddY P Q * (P 2 * Q 2) ^ 3 = (P 1 * Q 2 ^ 3 - Q 1 * P 2 ^ 3) ^ 3 | true |
Lean.Parser.ParserContext.setEndPos | Lean.Parser.Types | (c : Lean.Parser.ParserContext) →
(endPos : String.Pos.Raw) → endPos ≤ c.inputString.rawEndPos → Lean.Parser.ParserContext | true |
UniqueProds.of_injective_mulHom | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} {H : Type v} [inst : Mul G] [inst_1 : Mul H] (f : H →ₙ* G),
Function.Injective ⇑f → UniqueProds G → UniqueProds H | true |
CategoryTheory.Pretriangulated.invRotCompRot_hom_app_hom₂ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.Pretriangulated.invRotCompRot.hom.app X).hom₂ = ... | true |
PowerSeries.rescale_zero_apply | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (f : PowerSeries R),
(PowerSeries.rescale 0) f = PowerSeries.C (PowerSeries.constantCoeff f) | true |
AffineIsometryEquiv.linearIsometryEquiv | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : Nor... | true |
Polynomial.scaleRoots | Mathlib.RingTheory.Polynomial.ScaleRoots | {R : Type u_1} → [inst : Semiring R] → Polynomial R → R → Polynomial R | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry._unary.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : Type v} (_x : (x : Std.DTreeMap.Internal.Impl α fun x => β) ×' x.isEmpty = false),
Std.DTreeMap.Internal.Impl.Const.maxEntry._unary _x =
PSigma.casesOn _x fun t h =>
match t, h with
| Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf, x => (k, v)
| S... | false |
Finset.sum_ite_eq' | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (a : ι) (b : ι → M),
(∑ x ∈ s, if x = a then b x else 0) = if a ∈ s then b a else 0 | true |
Set.Unbounded.eq_1 | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) (s : Set α), Set.Unbounded r s = ∀ (a : α), ∃ b ∈ s, ¬r b a | true |
RingQuot.Rel.brecOn | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {r : R → R → Prop} {motive : (a a_1 : R) → RingQuot.Rel r a a_1 → Prop} {a a_1 : R}
(t : RingQuot.Rel r a a_1),
(∀ (a a_2 : R) (t : RingQuot.Rel r a a_2), RingQuot.Rel.below t → motive a a_2 t) → motive a a_1 t | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceOpcycles_exact._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.