name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Class.coe_sUnion._simp_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x : ZFSet.{u}), (↑x).sUnion = ↑x.sUnion | false |
_private.Mathlib.Order.Filter.Basic.0.Filter.mem_iInf_of_directed._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Affine.Simplex.excenterWeightsUnnorm | Mathlib.Geometry.Euclidean.Incenter | {V : Type u_1} →
{P : Type u_2} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] →
[inst_2 : MetricSpace P] →
[inst_3 : NormedAddTorsor V P] →
{n : ℕ} → [NeZero n] → Affine.Simplex ℝ P n → Finset (Fin (n + 1)) → Fin (n + 1) → ℝ | true |
Submodule.smithNormalFormOfLE._proof_5 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(N O : Submodule R M) (n o : ℕ),
(∃ (hno : n ≤ o), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i))) → n ≤ o | false |
Lean.Grind.imp_eq_of_eq_false_left | Init.Grind.Lemmas | ∀ {a b : Prop}, a = False → (a → b) = True | true |
instLEBitVec | Init.Prelude | {w : ℕ} → LE (BitVec w) | true |
tangentMapWithin_eq_tangentMap | Mathlib.Geometry.Manifold.MFDeriv.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}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
SeparationQuotient.instNonAssocRing._proof_7 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R], SeparationQuotient.mk 0 = 0 | false |
CategoryTheory.GrothendieckTopology.pointBot_fiber | Mathlib.CategoryTheory.Sites.Point.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] (X : C),
(CategoryTheory.GrothendieckTopology.pointBot X).fiber =
CategoryTheory.shrinkYoneda.{w, v, u}.flip.obj (Opposite.op X) | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.red_iff_irreducible._simp_1_4 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (a : α) (l : List α), (a :: l = []) = False | false |
ContDiffMapSupportedIn.compact_supp | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
HasCompactSupport ⇑f | true |
CategoryTheory.instRepresentablyCoflatIndYoneda | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], CategoryTheory.RepresentablyCoflat CategoryTheory.Ind.yoneda | true |
_private.Mathlib.Tactic.Linter.DeprecatedSyntaxLinter.0.Mathlib.Linter.Style.isDecideNative | Mathlib.Tactic.Linter.DeprecatedSyntaxLinter | Lean.Syntax → Bool | true |
_private.Mathlib.Order.WellFounded.0.exists_not_acc_lt_of_not_acc._simp_1_1 | Mathlib.Order.WellFounded | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
lt_of_mul_lt_mul_left | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [PosMulReflectLT α],
a * b < a * c → 0 ≤ a → b < c | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_diff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} [Finite ι] {s₁ s₂ : Set (ι → ℕ)}, IsSemilinearSet s₁ → IsSemilinearSet s₂ → IsSemilinearSet (s₁ \ s₂) | true |
CompleteLattice.MulticoequalizerDiagram.multicofork._proof_1 | Mathlib.Order.CompleteLattice.MulticoequalizerDiagram | ∀ {T : Type u_1} [inst : CompleteLattice T] {ι : Type u_2} {x : T} {u : ι → T} {v : ι → ι → T}
(d : CompleteLattice.MulticoequalizerDiagram x u v) (x_1 : (CategoryTheory.Limits.MultispanShape.prod ι).L),
d.multispanIndex.right ((CategoryTheory.Limits.MultispanShape.prod ι).fst x_1) ≤ x | false |
Sym2.instDecidableRel._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x x_1 : α × α),
Sym2.Rel α (x.1, x.2) (x_1.1, x_1.2) ↔ x.1 = x_1.1 ∧ x.2 = x_1.2 ∨ x.1 = x_1.2 ∧ x.2 = x_1.1 | false |
Lean.Meta.Sym.ProofInstInfo.noConfusionType | Lean.Meta.Sym.SymM | Sort u → Lean.Meta.Sym.ProofInstInfo → Lean.Meta.Sym.ProofInstInfo → Sort u | false |
Algebra.adjoin_mono | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s t : Set A},
s ⊆ t → Algebra.adjoin R s ≤ Algebra.adjoin R t | true |
ValuationSubring.instIsScalarTowerSubtypeMemValuationSubringWithZeroMultiplicativeInt | Mathlib.RingTheory.Valuation.AlgebraInstances | ∀ {K : Type u_1} [inst : Field K] (v : Valuation K (WithZero (Multiplicative ℤ))) (L : Type u_2) [inst_1 : Field L]
[inst_2 : Algebra K L] (E : Type u_3) [inst_3 : Field E] [inst_4 : Algebra K E] [inst_5 : Algebra L E]
[IsScalarTower K L E], IsScalarTower (↥v.valuationSubring) L E | true |
Array.swap_perm | Init.Data.Array.Perm | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ} (h₁ : i < xs.size) (h₂ : j < xs.size), (xs.swap i j h₁ h₂).Perm xs | true |
HomologicalComplex.HomologySequence.snakeInput._proof_1 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_3} {ι : Type u_1} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (i : ι), (HomologicalComplex.homologyFunctor C c i).PreservesZeroMorphisms | false |
Std.TreeMap.Raw.getElem!_filter | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {f : α → β → Bool} {k : α} (h : t.WF),
(Std.TreeMap.Raw.filter f t)[k]! = (t[k]?.pfilter fun x h' => f (t.getKey k ⋯) x).get! | true |
ConvexCone.closure_eq | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] {E : Type u_2} [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : SMul 𝕜 E] [inst_6 : ContinuousConstSMul 𝕜 E]
{K L : ConvexCone 𝕜 E}, K.closure = L ↔ closure ↑K = ↑L | true |
SSet.Subcomplex.liftPath._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet} (A : X.Subcomplex) {n : ℕ} (p : X.Path n),
(∀ (j : Fin (n + 1)), p.vertex j ∈ A.obj (Opposite.op (SimplexCategory.mk 0))) →
∀ (j : Fin n), p.vertex j.castSucc ∈ A.obj (Opposite.op (SimplexCategory.mk 0)) | false |
SummationFilter.mk.sizeOf_spec | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_4} [inst : SizeOf β] (filter : Filter (Finset β)), sizeOf { filter := filter } = 1 + sizeOf filter | true |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.instLawfulUpwardEnumerableLTOfLawfulUpwardEnumerableOfLawfulUpwardEnumerableLEOfLawfulOrderLT._simp_1 | Init.Data.Range.Polymorphic.Instances | ∀ {α : Type u} {inst : LT α} {inst_1 : LE α} [self : Std.LawfulOrderLT α] (a b : α), (a < b) = (a ≤ b ∧ ¬b ≤ a) | false |
Matrix.IsSymm.transpose | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.IsSymm → A.transpose.IsSymm | true |
ENNReal.add_div | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, (a + b) / c = a / c + b / c | true |
instAddMonoidLex.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : AddMonoid α], instAddMonoidLex = h | true |
Lean.Elab.Tactic.evalInhabit | Mathlib.Tactic.Inhabit | Lean.MVarId → Option Lean.Ident → Lean.Syntax → Lean.Elab.Tactic.TacticM Lean.MVarId | true |
Lean.Meta.SolveByElim.SolveByElimConfig.maxDepth._default | Lean.Meta.Tactic.SolveByElim | ℕ | false |
List.prev._unsafe_rec | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (l : List α) → (x : α) → x ∈ l → α | false |
Nucleus.instCompleteLattice._proof_1 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : CompleteLattice X] (a b : Nucleus X), a ≤ SemilatticeSup.sup a b | false |
Lean.Elab.Do.ControlLifter.rec | Lean.Elab.Do.Control | {motive : Lean.Elab.Do.ControlLifter → Sort u} →
((origCont : Lean.Elab.Do.DoElemCont) →
(returnBase? breakBase? continueBase? : Option Lean.Elab.Do.ControlStack) →
(pureBase : Lean.Elab.Do.ControlStack) →
(pureDeadCode : Lean.Elab.Do.CodeLiveness) →
(liftedDoBlockResultType : Lean... | false |
Nat.castEmbedding | Mathlib.Algebra.Ring.CharZero | {R : Type u_2} → [inst : AddMonoidWithOne R] → [CharZero R] → ℕ ↪ R | true |
_private.Mathlib.Data.List.Forall2.0.List.Forall₂.get.match_1_4 | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
(funType_1 :
(x : List α) → (x_1 : List β) → List.Forall₂ R x x_1 → (x_3 : ℕ) → x_3 < x.length → x_3 < x_1.length → Prop)
(motive :
(x : List α) →
(x_1 : List β) →
(x_2 : List.Forall₂ R x x_1) →
List.Forall₂.below (motive := fun x x_... | false |
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.succ?_eq_some._simp_1_4 | Init.Data.Range.Polymorphic.BitVec | ∀ {β : Type u_1} {a : β} {p : Prop} {x : Decidable p} {b : Option β},
((if p then none else b) = some a) = (¬p ∧ b = some a) | false |
isLeftRegular_iff_isRegular | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : CommMagma G] {a : G}, IsLeftRegular a ↔ IsRegular a | true |
_private.Init.Data.String.Substring.0.Substring.Raw.get.match_1.eq_1 | Init.Data.String.Substring | ∀ (motive : Substring.Raw → String.Pos.Raw → Sort u_1) (s : String) (b stopPos p : String.Pos.Raw)
(h_1 : (s : String) → (b stopPos p : String.Pos.Raw) → motive { str := s, startPos := b, stopPos := stopPos } p),
(match { str := s, startPos := b, stopPos := stopPos }, p with
| { str := s, startPos := b, stopPos... | true |
MeasureTheory.AddContent.isCaratheodory_inducedOuterMeasure_of_mem | Mathlib.MeasureTheory.OuterMeasure.OfAddContent | ∀ {α : Type u_1} {C : Set (Set α)} (hC : MeasureTheory.IsSetSemiring C) (m : MeasureTheory.AddContent ENNReal C)
{s : Set α}, s ∈ C → (MeasureTheory.inducedOuterMeasure (fun x x_1 => m x) ⋯ ⋯).IsCaratheodory s | true |
FiniteMulArchimedeanClass.mk._proof_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] (a : M),
a ≠ 1 → ¬MulArchimedeanClass.mk a = ⊤ | false |
List.decidableLE._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1} [inst : LT α] (l₁ l₂ : List α), l₂ < l₁ → ¬l₂ < l₁ → False | false |
FreeAddMonoid.length_eq_zero | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {a : FreeAddMonoid α}, a.length = 0 ↔ a = 0 | true |
Lean.Meta.SolveByElim.ApplyRulesConfig.ctorIdx | Lean.Meta.Tactic.SolveByElim | Lean.Meta.SolveByElim.ApplyRulesConfig → ℕ | false |
eq_one_of_mul_le_one_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : PartialOrder α] [MulLeftMono α] {a b : α},
1 ≤ a → 1 ≤ b → a * b ≤ 1 → a = 1 | true |
List.Perm.foldl_eq' | Init.Data.List.Perm | ∀ {β : Type u_1} {α : Type u_2} {f : β → α → β} {l₁ l₂ : List α},
l₁.Perm l₂ →
(∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z : β), f (f z x) y = f (f z y) x) →
∀ (init : β), List.foldl f init l₁ = List.foldl f init l₂ | true |
Affine.Simplex.sign_excenterWeights_singleton_pos | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) [n.AtLeastTwo]
{i j : Fin (n + 1)}, i ≠ j → SignType.sign (s.excenterWeights {i} j) = 1 | true |
Std.Internal.Parsec.String.take | Std.Internal.Parsec.String | ℕ → Std.Internal.Parsec.String.Parser String | true |
ContinuousLinearEquiv.continuousAlternatingMapCongrRightEquiv | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_4} →
{N' : Type u_5} →
{ι : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
[inst_4 : AddCommMonoid N] →
... | true |
Lean.SMap.find? | Lean.Data.SMap | {α : Type u} → {β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.SMap α β → α → Option β | true |
Polynomial.exists_monic_irreducible_factor | Mathlib.RingTheory.Polynomial.UniqueFactorization | ∀ {F : Type u_1} [inst : Field F] (f : Polynomial F), ¬IsUnit f → ∃ g, g.Monic ∧ Irreducible g ∧ g ∣ f | true |
_private.Init.Data.List.Sublist.0.List.Sublist.trans.match_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₂ : List α} (a : α) (motive : (l₂' l₁ : List α) → l₁.Sublist l₂' → a :: l₂ = l₂' → Prop)
(l₂' l₁ : List α) (h₁ : l₁.Sublist l₂') (e : a :: l₂ = l₂'),
(∀ (e : a :: l₂ = []), motive [] [] ⋯ e) →
(∀ (l₁ l₂_1 : List α) (a' : α) (h₁' : l₁.Sublist l₂_1) (e : a :: l₂ = a' :: l₂_1), motive (a' :: l₂_... | false |
Std.DTreeMap.Internal.Impl.WF.below.insert | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} {v : x k} (a : t.WF),
Std.DTreeMap.Internal.Impl.WF.below a → motive t a → Std.DTreeMap.Internal.Impl.WF.below ⋯ | true |
HomologicalComplex.exactAt_iff_isZero_homology | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i : ι) [inst_2 : K.HasHomology i],
K.ExactAt i ↔ CategoryTheory.Limits.IsZero (K.homology i) | true |
CochainComplex.mappingCone.lift.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
(α α_1 : CochainComplex.HomComplex.Cocycle K F 1) (e_α : α = α_1) (β β_1 : CochainComplex.HomComplex... | true |
Lean.Compiler.LCNF.Simp.Config.etaPoly._default | Lean.Compiler.LCNF.Simp.Config | Bool | false |
_private.Lean.Elab.Calc.0.Lean.Elab.Term.annotateFirstHoleWithType.go | Lean.Elab.Calc | Lean.Expr → Lean.Syntax → StateT Bool Lean.Elab.TermElabM Lean.Syntax | true |
HopfAlgCat.Hom.toBialgHom | Mathlib.Algebra.Category.HopfAlgCat.Basic | {R : Type u} → [inst : CommRing R] → {X Y : HopfAlgCat R} → X.Hom Y → X.carrier →ₐc[R] Y.carrier | true |
_private.Init.Data.Range.Polymorphic.UInt.0.UInt8.instLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.UInt | ∀ {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec) | false |
AddGrpCat.FilteredColimits.colimitAddGroup._proof_2 | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J AddGrpCat) (a : ↑(AddGrpCat.FilteredColimits.G F)), zsmulRec nsmulRec 0 a = 0 | false |
_private.Mathlib.Algebra.Polynomial.Bivariate.0.Polynomial.Bivariate.swap_monomial._simp_1_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | false |
_private.Mathlib.RingTheory.Extension.Generators.0.Algebra.Generators.map_toComp_ker._simp_1_6 | Mathlib.RingTheory.Extension.Generators | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
Mathlib.Tactic.GCongr.Context._sizeOf_1 | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.Context → ℕ | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyCell_eq_apply_toListModel._simp_1_5 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
DirectSum.«_aux_Mathlib_Algebra_DirectSum_Basic___macroRules_DirectSum_term⨁_,__1» | Mathlib.Algebra.DirectSum.Basic | Lean.Macro | false |
Complex.sin_nat_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Complex.sin (↑n * ↑Real.pi) = 0 | true |
ConjAct.unitsMulSemiringAction | Mathlib.Algebra.Ring.Action.ConjAct | {R : Type u_1} → [inst : Semiring R] → MulSemiringAction (ConjAct Rˣ) R | true |
Lean.MessageData.kind._unsafe_rec | Lean.Message | Lean.MessageData → Lean.Name | false |
Std.Time.instFormatGenericFormatFormatTypeString | Std.Time.Format.Basic | {aw : Std.Time.Awareness} → Std.Time.Format (Std.Time.GenericFormat aw) fun x1 x2 => Std.Time.FormatType x1 x2.string | true |
SimplexCategory.mono_iff_injective | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n m : SimplexCategory} {f : n ⟶ m}, CategoryTheory.Mono f ↔ Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f) | true |
SimpleGraph.IsAcyclic.induce | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsAcyclic → ∀ (s : Set V), (SimpleGraph.induce s G).IsAcyclic | true |
AddRightCancelMonoid.recOn | Mathlib.Algebra.Group.Defs | {M : Type u} →
{motive : AddRightCancelMonoid M → Sort u_1} →
(t : AddRightCancelMonoid M) →
([toAddMonoid : AddMonoid M] →
[toIsRightCancelAdd : IsRightCancelAdd M] →
motive { toAddMonoid := toAddMonoid, toIsRightCancelAdd := toIsRightCancelAdd }) →
motive t | false |
CategoryTheory.Functor.projective_of_map_projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor C D) [F.Full] [F.Faithful] [F.PreservesEpimorphisms] {P : C},
CategoryTheory.Projective (F.obj P) → CategoryTheory.Projective P | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Flat.0.AlgebraicGeometry.isIso_pushoutSection_iff._proof_1_1 | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | false |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem?_toArray_rcc_eq_some_iff._simp_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Std.Time.ZonedDateTime.toRFC822String | Std.Time.Format | Std.Time.ZonedDateTime → String | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue?_eq_some_iff_exists_beq_and_mem_toList._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} {k : α} {v : β} {l : List ((_ : α) × β)},
((k, v) ∈ List.map (fun x => (x.fst, x.snd)) l) = (⟨k, v⟩ ∈ l) | false |
ByteArray.get_extract_aux | Batteries.Data.ByteArray | ∀ {i : ℕ} {a : ByteArray} {start stop : ℕ}, i < (a.extract start stop).size → start + i < a.size | true |
Std.ExtTreeMap.getKey!_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k a : α} {v : β}, (t.insert k v).getKey! a = if cmp k a = Ordering.eq then k else t.getKey! a | true |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_17 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : (PreQuasiregular A)ˣ),
{
val :=
PreQuasiregular.equiv
(↑↑⟨{ val := 1 + ↑(PreQuasiregular.equiv.symm ↑x), inv := 1 + ... | false |
ConjClasses.instDecidableEqOfDecidableRelIsConj._aux_1 | Mathlib.Algebra.Group.Conj | {α : Type u_1} → [inst : Monoid α] → [DecidableRel IsConj] → DecidableEq (ConjClasses α) | false |
CategoryTheory.ShortComplex.SnakeInput.epi_v₂₃_τ₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Epi S.v₂₃.τ₂ | true |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.chainTopCoeff_if_one_zero._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.Smooth.0.AlgebraicGeometry.instHasRingHomPropertySmoothOfRelativeDimensionLocallyIsStandardSmoothOfRelativeDimension._proof_5 | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (w : TopologicalSpace.Opens ↥Y)
(left_1 : AlgebraicGeometry.IsAffineOpen w) (w_1 : TopologicalSpace.Opens ↥X) (a : w_1 ∈ X.affineOpens),
w_1 ≤ (TopologicalSpace.Opens.map f.base).obj w → ↑⟨w_1, ⋯⟩ ≤ (TopologicalSpace.Opens.map f.base).obj ↑⟨w, ⋯⟩ | false |
Real.le_logb_iff_rpow_le | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x y : ℝ}, 1 < b → 0 < y → (x ≤ Real.logb b y ↔ b ^ x ≤ y) | true |
CategoryTheory.ExactFunctor.whiskeringLeft._proof_3 | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (C : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
(F : C ⥤ₑ D) (G : D ⥤ₑ E),
CategoryTheory.leftExactFunctor C E
(((CategoryTheory.ExactFunctor.forget D E).comp ((Catego... | false |
_private.Mathlib.Analysis.SpecificLimits.Basic.0.ENNReal.tendsto_pow_atTop_nhds_top_iff._simp_1_5 | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | false |
CommRingCat.limitCommRing._proof_45 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | false |
AddSubmonoid.instCompleteLattice._proof_5 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b : AddSubmonoid M), a ≤ b → b ≤ a → a = b | false |
CategoryTheory.RegularMono.lift' | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y W : C} →
{f : X ⟶ Y} →
(hf : CategoryTheory.RegularMono f) →
(k : W ⟶ Y) →
CategoryTheory.CategoryStruct.comp k hf.left = CategoryTheory.CategoryStruct.comp k hf.right →
{ l // CategoryTheory.Categ... | true |
Algebra.FormallySmooth.kerCotangentToTensor_injective_iff | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {P : Type u_2}
[inst_3 : CommRing P] [inst_4 : Algebra R P] [Algebra.FormallySmooth R P] [inst_6 : Algebra P A]
[IsScalarTower R P A],
Function.Surjective ⇑(algebraMap P A) →
(Function.Injective ⇑(KaehlerDifferential.... | true |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.noConfusion | Mathlib.AlgebraicGeometry.RelativeGluing | {P : Sort u_3} →
{S : AlgebraicGeometry.Scheme} →
{𝒰 : S.OpenCover} →
{inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀} →
{inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰} →
{t : AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰} →
{S' : AlgebraicGeometry.Scheme}... | false |
Finset.subtype_eq_univ._simp_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {s : Finset α} {p : α → Prop} [inst : DecidablePred p] [inst_1 : Fintype { a // p a }],
(Finset.subtype p s = Finset.univ) = ∀ ⦃a : α⦄, p a → a ∈ s | false |
CategoryTheory.Limits.spanCompIso_hom_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z),
(CategoryTheory.Limits.spanCompIso F f g).hom.app CategoryTheory.Limits.WalkingSpan.zero =
CategoryTheory.CategoryStruct.id
... | true |
Set.Ici_inter_Ici | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a b : α}, Set.Ici a ∩ Set.Ici b = Set.Ici (a ⊔ b) | true |
Vector.map_id'' | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {f : α → α}, (∀ (x : α), f x = x) → ∀ (xs : Vector α n), Vector.map f xs = xs | true |
Units.mk_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ) (y : α) (h₁ : ↑u * y = 1) (h₂ : y * ↑u = 1),
{ val := ↑u, inv := y, val_inv := h₁, inv_val := h₂ } = u | true |
NormedSpace.ofReal_exp_ℝ_ℝ._simp_1 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ (r : ℝ), NormedSpace.exp ↑r = ↑(NormedSpace.exp r) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.