name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_excenter_singleton_eq._proof_1_4 | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₃ : Fin 3},
i₁ ≠ i₃ → ∃ x, ¬x = i₃ ∧ t.points x = t.points i₁ | null | false |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (e e_1 : Lean.Expr),
(Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1) = (e = e_1) | null | true |
CategoryTheory.eHom_whisker_cancel_inv | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ (V : Type u') [inst : CategoryTheory.Category.{v', u'} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] {X Y Y₁ Z : C}
(α : Y ≅ Y₁),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCat... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt.0.CFC.conjSqrt_ringInverse_conjSqrt._proof_1_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [inst_8 : SeparatelyContinuousMul A] [IsSemitopologicalRing ... | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt64.zero_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.Forall.match_1.eq_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} (motive : (x : ℕ) → ((Fin x → α) → Prop) → Sort u_1) (P : (Fin 0 → α) → Prop)
(h_1 : (P : (Fin 0 → α) → Prop) → motive 0 P) (h_2 : (n : ℕ) → (P : (Fin (n + 1) → α) → Prop) → motive n.succ P),
(match 0, P with
| 0, P => h_1 P
| n.succ, P => h_2 n P) =
h_1 P | null | true |
CategoryTheory.Abelian.SpectralObject.zero₁_assoc | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ n... | null | true |
Lean.Omega.IntList.gcd_eq_zero._simp_1 | Init.Omega.IntList | ∀ {xs : Lean.Omega.IntList}, (xs.gcd = 0) = ∀ x ∈ xs, x = 0 | null | false |
Module.Basis.range_extend | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
(hs : LinearIndepOn K id s), Set.range ⇑(Module.Basis.extend hs) = hs.extend ⋯ | null | true |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Meta.Grind.AC.withExprs.go.match_1.eq_2 | Lean.Meta.Tactic.Grind.AC.Eq | ∀ (motive : List ℕ → List ℕ → Sort u_1) (x : List ℕ) (h_1 : (x : List ℕ) → motive [] x)
(h_2 : (x : List ℕ) → motive x [])
(h_3 : (id₁ : ℕ) → (ids₁ : List ℕ) → (id₂ : ℕ) → (ids₂ : List ℕ) → motive (id₁ :: ids₁) (id₂ :: ids₂)),
(x = [] → False) →
(match x, [] with
| [], x => h_1 x
| x, [] => h_2 x
... | null | true |
Ring.DirectLimit.lift_of | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) (i : ι) (x : G i),
(Ring.DirectLimit.lift G f P g... | null | true |
NonUnitalSubsemiring.prodEquiv | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
(s : NonUnitalSubsemiring R) → (t : NonUnitalSubsemiring S) → ↥(s.prod t) ≃+* ↥s × ↥t | Product of non-unital subsemirings is isomorphic to their product as semigroups. | true |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.casesOn | Lean.Meta.InferType | {motive : Lean.Meta.ArrowPropResult✝ → Sort u} →
(t : Lean.Meta.ArrowPropResult✝) →
motive Lean.Meta.ArrowPropResult.false✝ →
motive Lean.Meta.ArrowPropResult.true✝ →
motive Lean.Meta.ArrowPropResult.undef✝ → ((idx : ℕ) → motive (Lean.Meta.ArrowPropResult.bvar✝ idx)) → motive t | null | false |
Std.TreeMap.Raw.contains_iff_mem._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {k : α},
(t.contains k = true) = (k ∈ t) | null | false |
Lean.Elab.Command.InductiveElabStep2 | Lean.Elab.MutualInductive | Type | An intermediate step for mutual inductive elaboration. See `InductiveElabDescr`. | true |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.mkUnusedName.loop | Mathlib.Tactic.CategoryTheory.Elementwise | List Lean.Name → Lean.Name → optParam ℕ 0 → Lean.Name | null | true |
GradedAlgHom.mk.injEq | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | null | true |
CategoryTheory.Monad.monadicOfHasPreservesReflexiveCoequalizersOfReflectsIsomorphisms._proof_1 | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D}
(adj : F ⊣ G) [CategoryTheory.Limits.HasReflexiveCoequalizers D] [G.ReflectsIsomorphisms]
[CategoryTheory.Monad.PreservesC... | null | false |
Lean.Meta.Grind.AC.ProofM.State.exprDecls | Lean.Meta.Tactic.Grind.AC.Proof | Lean.Meta.Grind.AC.ProofM.State → Std.HashMap Lean.Grind.AC.Expr Lean.Expr | null | true |
Lean.Parser.Module.prelude | Lean.Parser.Module.Syntax | Lean.Parser.Parser | null | true |
sigmaFinsuppEquivDFinsupp_symm_apply | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {η : ι → Type u_4} {N : Type u_5} [inst : Zero N] (f : Π₀ (i : ι), η i →₀ N) (s : (i : ι) × η i),
(sigmaFinsuppEquivDFinsupp.symm f) s = (f s.fst) s.snd | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_14 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α}, j ≤ a.size → (a ++ b).extract i j = a.extract i j | null | false |
AlgebraicGeometry.specOrderIsoPrimeSpectrum_apply | Mathlib.AlgebraicGeometry.Scheme | ∀ (R : CommRingCat) (x : ↥(AlgebraicGeometry.Spec R)),
(AlgebraicGeometry.specOrderIsoPrimeSpectrum R) x = OrderDual.toDual x | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Symmetric.0.Submodule.isSymmetric_projection_iff._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E}, (inner 𝕜 x y = 0) = (inner 𝕜 y x = 0) | null | false |
UInt8.ofBitVec_shiftRight_mod | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8) (b : ℕ), { toBitVec := a >>> (b % 8) } = { toBitVec := a } >>> UInt8.ofNat b | null | true |
Std.Time.TimeZone.convertTZif | Std.Time.Zoned.Database.Basic | Std.Time.TimeZone.TZif.TZif → String → Except String Std.Time.TimeZone.ZoneRules | Converts a `TZif.TZif` structure to a `ZoneRules` structure.
| true |
_private.Init.Data.Iterators.Lemmas.Consumers.Collect.0.Std.Iter.atIdxSlow?.match_1.eq_2 | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β)
(motive :
(n : ℕ) →
((a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, n⟩ →... | null | true |
Array.getElem_toList | Init.Data.Array.Basic | ∀ {α : Type u} {xs : Array α} {i : ℕ} (h : i < xs.size), xs.toList[i] = xs[i] | null | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.Structured.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : Lean.Json.Structured → Sort u_1) →
(x : Lean.Json.Structured) →
((a : Array Lean.Json) → motive (Lean.Json.Structured.arr a)) →
((o : Std.TreeMap.Raw String Lean.Json compare) → motive (Lean.Json.Structured.obj o)) → motive x | null | false |
Aesop.PatSubstSource.casesOn | Aesop.Forward.State | {motive : Aesop.PatSubstSource → Sort u} →
(t : Aesop.PatSubstSource) →
((fvarId : Lean.FVarId) → motive (Aesop.PatSubstSource.hyp fvarId)) → motive Aesop.PatSubstSource.target → motive t | null | false |
_private.Std.Internal.Do.WP.Lemmas.0.EStateM.tryCatch.match_1.eq_2 | Std.Internal.Do.WP.Lemmas | ∀ {ε σ α : Type u_1} (motive : EStateM.Result ε σ α → Sort u_2) (ok : EStateM.Result ε σ α)
(h_1 : (e : ε) → (s : σ) → motive (EStateM.Result.error e s)) (h_2 : (ok : EStateM.Result ε σ α) → motive ok),
(∀ (e : ε) (s : σ), ok = EStateM.Result.error e s → False) →
(match ok with
| EStateM.Result.error e s ... | null | true |
LieHom.mem_idealRange_iff._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L'),
f.IsIdealMorphism → ∀ {y : L'}, (y ∈ f.idealRange) = ∃ x, f x = y | null | false |
CategoryTheory.SmallObject.SuccStruct.isColimitIterationCocone | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryThe... | `Φ.iteration J` identifies to the colimit of `Φ.iterationFunctor J`. | true |
ULift.group._proof_6 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Group α] (x : ULift.{u_1, u_2} α) (x_1 : ℤ), Equiv.ulift (x ^ x_1) = Equiv.ulift (x ^ x_1) | null | false |
MeasureTheory.innerRegular_map_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.InnerRegular] (g : G),
(MeasureTheory.Measure.map (fun x => g + x) μ).InnerRegular | The image of an inner regular measure under left addition is again inner regular. | true |
WithBot.unbotD_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] (d : α), WithBot.unbotD d 0 = 0 | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_11 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k < ↑i - 1 → ¬↑k + 1 < ↑j → ↑k < ↑j → ↑k < ↑i → ↑k + 1 + 1 = ↑k | null | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_finite._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) | null | false |
CategoryTheory.ObjectProperty.strictLimitsOfShape_monotone | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] {Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.strictLimitsOfShape J ≤ Q.strictLimitsOfShape J | null | true |
BddAbove.smul_of_nonpos | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [inst_3 : AddCommGroup β]
[inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β] {s : Set β} {a : α},
a ≤ 0 → BddAbove s → BddBelow (a • s) | null | true |
Orientation.norm_div_tan_oangle_sub_left_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖y‖ / (o.oangle (x - y) x).tan = ‖x‖ | A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side, version subtracting vectors. | true |
List.eraseIdx_modify_of_eq | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i : ℕ) (l : List α), (l.modify i f).eraseIdx i = l.eraseIdx i | null | true |
ULift.ring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Ring R] (n : ℕ) (a : ULift.{u_1, u_2} R),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | null | false |
AEMeasurable.cexp | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℂ},
AEMeasurable f μ → AEMeasurable (fun x => Complex.exp (f x)) μ | null | true |
NumberField.instCommRingInfiniteAdeleRing._aux_32 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) → [inst : Field K] → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K | null | false |
Sym2.hrec._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {motive : Sym2 α → Sort u_2} (f : (a b : α) → motive s(a, b)),
(∀ (a b : α), f a b ≍ f b a) →
∀ (a b : α × α),
Sym2.Rel α a b →
(match a with
| (a, b) => f a b) ≍
match b with
| (a, b) => f a b | null | false |
ValuationRing.instOfIsLocalRingOfIsBezout | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsLocalRing R] [IsBezout R], ValuationRing R | null | true |
RingHom.SurjectiveOnStalks.baseChange | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {T : Type u_3} [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra R S],
(algebraMap R T).SurjectiveOnStalks → (algebraMap S (TensorProduct R S T)).SurjectiveOnStalks | null | true |
Int.bmod_eq_of_le_mul_two | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {y : ℕ}, -↑y ≤ x * 2 → x * 2 < ↑y → x.bmod y = x | null | true |
Commute.conj | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → ∀ (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) | null | true |
lp.instNormedSpace._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_1} {α : Type u_3} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedField 𝕜]
[inst_2 : (i : α) → NormedSpace 𝕜 (E i)] (i : α), IsBoundedSMul 𝕜 (E i) | null | false |
ContinuousAffineMap.toContinuousMap_coe | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (f : P →ᴬ[R] Q), ... | null | true |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_2} {D : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
(x : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))),
(CategoryTheory.MonoidalCateg... | null | false |
Lean.EnvironmentHeader._proof_1 | Lean.Environment | ∀ (modules : Array Lean.EffectiveImport), ∀ idx ∈ [:modules.size], idx < modules.size | null | false |
_private.Init.WFComputable.0.Acc.recC._unary._proof_6 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} (y : (a : α) ×' Acc r a), Acc r y.1 | null | false |
Int.neg_le_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → -b ≤ -a | null | true |
Lean.MonadFileMap.noConfusion | Lean.Data.Position | {P : Sort u} →
{m : Type → Type} →
{t : Lean.MonadFileMap m} →
{m' : Type → Type} → {t' : Lean.MonadFileMap m'} → m = m' → t ≍ t' → Lean.MonadFileMap.noConfusionType P t t' | null | false |
String.Slice.Subslice.noConfusionType | Init.Data.String.Subslice | Sort u → {s : String.Slice} → s.Subslice → {s' : String.Slice} → s'.Subslice → Sort u | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_Y | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y), (I.precomp g).Y = Z | null | true |
Polynomial.aeval.eq_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
Polynomial.aeval x = (Polynomial.aevalEquiv R A) x | null | true |
CategoryTheory.JointlyFaithful.map_injective | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
CategoryTheory.JointlyFaithful F → ∀ {X Y : C} {f g : X ⟶ Y}, (∀ (i : I), (F i).map f = (F i).map g) → f = g | null | true |
TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal | Mathlib.Topology.Sheaves.PUnit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : TopCat.Presheaf C (TopCat.of PUnit.{u_1 + 1})),
F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op ⊥))) | null | true |
CategoryTheory.ShortComplex.homologyMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasHomology] [inst_5 : S₂.HasHomology],
CategoryTheory.ShortCo... | null | true |
Nat.gcd_mul_left_sub_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, n ≤ m * k → m.gcd (m * k - n) = m.gcd n | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue_filter_not_contains._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | null | false |
Mathlib.Tactic.Translate.etaExpandN | Mathlib.Tactic.Translate.Core | ℕ → Lean.Expr → Lean.MetaM Lean.Expr | Eta expands `e` exactly `n` times. | true |
Cardinal.add_nat_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}} (n : ℕ), α + ↑n = β + ↑n ↔ α = β | null | true |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.instIsLeftCancelMulZeroOfIsCancelAddOfUniqueProds._simp_3 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] {a b c : G}, (b + a = c + a) = (b = c) | null | false |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_6 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
s = {t | t ∈ s ∧ IsOpen t} ∪ {t | t ∈ s ∧ IsClosed t} → {t | t ∈ s ∧ IsOpen t} ⊆ s | null | false |
TopologicalSpace.OpenNhdsOf.rec | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
[inst : TopologicalSpace α] →
{x : α} →
{motive : TopologicalSpace.OpenNhdsOf x → Sort u} →
((toOpens : TopologicalSpace.Opens α) →
(mem' : x ∈ toOpens.carrier) → motive { toOpens := toOpens, mem' := mem' }) →
(t : TopologicalSpace.OpenNhdsOf x) → motive t | null | false |
Lean.Parser.Tactic.Conv.pattern | Init.Conv | Lean.ParserDescr | * `pattern pat` traverses to the first subterm of the target that matches `pat`.
* `pattern (occs := *) pat` traverses to every subterm of the target that matches `pat`
which is not contained in another match of `pat`. It generates one subgoal for each matching
subterm.
* `pattern (occs := 1 2 4) pat` matches occur... | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.specializes_iff_of_t1Space._simp_1_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α}, s ⤳ t = ((∀ x ∈ s, ∃ y ∈ t, x ⤳ y) ∧ t ⊆ closure s) | null | false |
HomologicalComplex.Hom.comm_from | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁.Hom C₂) (i : ι),
CategoryTheory.CategoryStruct.comp (f.f i) (C₂.dFrom i) = CategoryTheory.CategoryStruct.comp (C₁.dFrom i) (f.ne... | null | true |
_private.Mathlib.Order.Nucleus.0.Nucleus.range.instFrameMinimalAxioms._simp_1 | Mathlib.Order.Nucleus | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (x ≤ y) = (↑x ≤ ↑y) | null | false |
StarMonoidHom.coe_one | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} [inst : Monoid A] [inst_1 : Star A], ⇑1 = id | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.finrank.eq_1 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (s : ↥S),
AlgebraicGeometry.Scheme.Hom.finrank f s =
AlgebraicGeometry.IsAffine.finrank✝
(CategoryTheory.Limits.pullback.snd f (S.affineOpenCover.f (S.affineOpenCover.idx s))) (Exists.choose ⋯) | null | true |
_private.Mathlib.RingTheory.OreLocalization.NonZeroDivisors.0.OreLocalization.inv._simp_2 | Mathlib.RingTheory.OreLocalization.NonZeroDivisors | ∀ {a : Prop}, (a ∨ a) = a | null | false |
CategoryTheory.Bicategory.leftAdjointSquare.comp_hvcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d e f x y z : B} {g₁ : a ⟶ d} {h₁ : b ⟶ e} {k₁ : c ⟶ f}
{g₂ : d ⟶ x} {h₂ : e ⟶ y} {k₂ : f ⟶ z} {l₁ : a ⟶ b} {l₂ : b ⟶ c} {l₃ : d ⟶ e} {l₄ : e ⟶ f} {l₅ : x ⟶ y} {l₆ : y ⟶ z}
(α : CategoryTheory.CategoryStruct.comp g₁ l₃ ⟶ CategoryTheory.CategoryStruct.comp l... | Horizontal and vertical composition of squares commutes. | true |
LieAlgebra.Basis.root_mem_or_mem_neg | Mathlib.Algebra.Lie.Basis | ∀ {ι : Type u_1} {K : Type u_2} {L : Type u_3} [inst : Fintype ι] [inst_1 : Field K] [inst_2 : CharZero K]
[inst_3 : LieRing L] [inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] (b : LieAlgebra.Basis ι K L)
[inst_6 : LieModule.IsTriangularizable K (↥b.cartan) L] [inst_7 : LieAlgebra.IsKilling K L] (χ : ↥Li... | null | true |
PowerSeries.derivative_invOf | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommRing R] (f : PowerSeries R) [inst_1 : Invertible f],
(PowerSeries.derivative R) ⅟f = -⅟f ^ 2 * (PowerSeries.derivative R) f | null | true |
instModuleGradedTensorProduct._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ (R : Type u_1) {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
_private.Lean.Meta.Tactic.Cbv.ControlFlow.0.Lean.Meta.Sym.Simp.simpDecideCbv | Lean.Meta.Tactic.Cbv.ControlFlow | Lean.Meta.Sym.Simp.Simproc | Simplify `Decidable.decide` by simplifying the proposition and reducing the instance.
First simplifies the proposition `p`. If the result is `True` or `False`, produces the
corresponding boolean directly. Otherwise, simplifies the `Decidable` instance and matches
on `isTrue`/`isFalse` to determine the boolean value. W... | true |
DerivedCategory.triangleOfSESδ._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (i : ℤ),
(HomologicalComplex.sc (CochainComplex.mappingCone S.f) i).HasHomology | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.iPending | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.State✝ → Array (Lean.Expr × Lean.Expr) | null | true |
Std.DHashMap.contains_of_contains_insertIfNew' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | This is a restatement of `contains_of_contains_insertIfNew` that is written to exactly match the proof
obligation in the statement of `get_insertIfNew`. | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsSlice | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | {M : Type u_1} → [Add M] → Set M → Prop | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_minKey?._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Perfection.instCommMonoid | Mathlib.RingTheory.Perfection | (M : Type u_1) → [inst : CommMonoid M] → (p : ℕ) → CommMonoid (Perfection M p) | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestRevMatchAt_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt pat pos₁ pos₂ =
∃ (h : pos₁ ≤ pos₂), String.Slice.Pattern.Model.IsLongestRevMatch pat (pos₂.sliceTo pos₁ h) | null | false |
Finite.equivFinOfCardEq | Mathlib.SetTheory.Cardinal.NatCard | {α : Type u_1} → [Finite α] → {n : ℕ} → Nat.card α = n → α ≃ Fin n | Similar to `Finite.equivFin` but with control over the term used for the cardinality. | true |
NonUnitalSubring.center.instNonUnitalCommRing._proof_11 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] (a : ↥(NonUnitalSubring.center R)), 0 * a = 0 | null | false |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.of_equivalence._simp_1_1 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC.0.Lean.Meta.Grind.Arith.Cutsat.isNonlinearTerm | Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC | Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
WithTop.le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithTop α}, x ≤ ↑a ↔ ∃ b, x = ↑b ∧ b ≤ a | null | true |
LinearOrder.supClosed._simp_2 | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : LinearOrder α] (s : Set α), SupClosed s = True | null | false |
Option.bind.match_1 | Init.Data.Option.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → (α → Option β) → Sort u_3) →
(x : Option α) →
(x_1 : α → Option β) →
((x : α → Option β) → motive none x) → ((a : α) → (f : α → Option β) → motive (some a) f) → motive x x_1 | null | false |
IsNowhereDense.closure | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsNowhereDense (closure s) | If a set `s` is nowhere dense, so is its closure. | true |
CategoryTheory.SimplicialObject.Homotopy.h_succ_comp_δ_castSucc_succ_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (j : Fin (n + 1)) {Z : C}
(h : Y.obj (Opposite.op { len := n + 1 }) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.h j.succ) (CategoryTheor... | null | true |
CategoryTheory.Functor.PreservesEffectiveEpis.recOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpis → Sort u} →
(t : F.PreservesEffectiveEpis) →
((preserves :
... | null | false |
Real.«term√_» | Mathlib.Analysis.Real.Sqrt | Lean.ParserDescr | The square root of a real number. This returns 0 for negative inputs.
This has notation `√x`. Note that `√x⁻¹` is parsed as `√(x⁻¹)`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.