name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.colimitUncurryIsoColimitCompColim_ι_ι_inv_assoc | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 :... | true |
Option.attach_map | Init.Data.Option.Attach | ∀ {α : Type u_1} {β : Type u_2} {o : Option α} (f : α → β),
(Option.map f o).attach =
Option.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨f x, ⋯⟩)
o.attach | true |
Lean.Elab.InlayHintInfo.mk.noConfusion | Lean.Elab.InfoTree.InlayHints | {P : Sort u} →
{position : String.Pos.Raw} →
{label : Lean.Elab.InlayHintLabel} →
{kind? : Option Lean.Elab.InlayHintKind} →
{textEdits : Array Lean.Elab.InlayHintTextEdit} →
{tooltip? : Option String} →
{paddingLeft paddingRight : Bool} →
{position' : String.Pos.... | false |
ENat.WithBot.add_one_le_zero_iff._simp_1 | Mathlib.Data.ENat.Basic | ∀ (n : WithBot ℕ∞), (n + 1 ≤ 0) = (n = ⊥) | false |
Finset.imageZeroHom_apply | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : DecidableEq β] [inst_2 : Zero β]
[inst_3 : FunLike F α β] [inst_4 : ZeroHomClass F α β] (f : F) (s : Finset α),
(Finset.imageZeroHom f) s = Finset.image (⇑f) s | true |
Star.ctorIdx | Mathlib.Algebra.Notation.Defs | {R : Type u} → Star R → ℕ | false |
CategoryTheory.Adjunction.mapAddGrp_counit | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (a : F ⊣ G) [inst_4 : ... | true |
_private.Mathlib.Algebra.CharP.Two.0.CharTwo.sqAddMonoidHom._proof_1 | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : CommSemiring R], 0 ^ 2 = 0 | false |
_private.Mathlib.RingTheory.Polynomial.Bernstein.0.bernsteinPolynomial.linearIndependent_aux._simp_1_7 | Mathlib.RingTheory.Polynomial.Bernstein | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) | false |
CategoryTheory.sheafComposeNatIso | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Funct... | true |
Lean.Grind.Linarith.Poly.denote'.go.match_1 | Init.Grind.Ordered.Linarith | (motive : Lean.Grind.Linarith.Poly → Sort u_1) →
(p : Lean.Grind.Linarith.Poly) →
(Unit → motive Lean.Grind.Linarith.Poly.nil) →
((v : Lean.Grind.Linarith.Var) → (p : Lean.Grind.Linarith.Poly) → motive (Lean.Grind.Linarith.Poly.add 1 v p)) →
((k : ℤ) →
(v : Lean.Grind.Linarith.Var) →
... | false |
DirectSum.mul_eq_dfinsuppSum | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] [inst_4 : (i : ι) → (x : A i) → Decidable (x ≠ 0)]
(a a' : DirectSum ι fun i => A i),
a * a' =
DFinsupp.sum a fun x ai => DFinsupp.sum a' fun x_1 aj => (D... | true |
HahnModule.instBaseModule._proof_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ' : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ'] [inst_1 : AddCommMonoid V]
[inst_2 : Semiring R] [inst_3 : Module R V] (a : R) (x y : HahnModule Γ' R V), a • (x + y) = a • x + a • y | false |
Matrix.PosSemidef.zero | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R], Matrix.PosSemidef 0 | true |
CategoryTheory.PreZeroHypercover.sum_f_inr | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S) (i : F.I₀), (E.sum F).f (Sum.inr i) = F.f i | true |
Int.Linear.Expr.denoteExpr._sunfold | Lean.Meta.Tactic.Simp.Arith.Int.Basic | (ℕ → Lean.Expr) → Int.Linear.Expr → Lean.MetaM Lean.Expr | false |
TwoSidedIdeal.sup_ringCon | Mathlib.RingTheory.TwoSidedIdeal.Lattice | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] (I J : TwoSidedIdeal R), (I ⊔ J).ringCon = I.ringCon ⊔ J.ringCon | true |
Fin.one_le_of_ne_zero | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {k : Fin n}, k ≠ 0 → 1 ≤ k | true |
_private.Lean.Elab.Deriving.ToExpr.0.Lean.Elab.Deriving.ToExpr.mkInstanceCmds | Lean.Elab.Deriving.ToExpr | Lean.Elab.Deriving.Context → Array Lean.Name → Lean.Elab.TermElabM (Array Lean.Command) | true |
Algebra.isInvariant_iff | Mathlib.RingTheory.Invariant.Defs | ∀ (A : Type u_1) (B : Type u_2) (G : Type u_3) [inst : CommSemiring A] [inst_1 : Semiring B] [inst_2 : Algebra A B]
[inst_3 : Group G] [inst_4 : MulSemiringAction G B],
Algebra.IsInvariant A B G ↔ ∀ (b : B), (∀ (g : G), g • b = b) → ∃ a, (algebraMap A B) a = b | true |
Partition.Simps.coe | Mathlib.Order.Partition.Basic | {α : Type u_1} → [inst : CompleteLattice α] → {s : α} → Partition s → Set α | true |
Int.sub_bmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℕ) (b : ℤ), (↑a - b).bmod a = (-b).bmod a | true |
Std.Internal.IO.Async.System.instInhabitedGroupInfo | Std.Internal.Async.System | Inhabited Std.Internal.IO.Async.System.GroupInfo | true |
HomologicalComplex.homotopyCofiber.inrCompHomotopy_hom_eq_zero | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (hc : ∀ (j : ι), ∃ i, c.Rel i j) (i j : ι),
¬c.Rel ... | true |
CategoryTheory.Limits.coequalizer.cofork_ι_app_one | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasCoequalizer f g],
(CategoryTheory.Limits.coequalizer.cofork f g).ι.app CategoryTheory.Limits.WalkingParallelPair.one =
CategoryTheory.Limits.coequalizer.π f g | true |
Mathlib.Tactic.BicategoryLike.MonadMor₂.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{P : Sort u} →
{homM : Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂} →
{atomHomM : Mathlib.Tactic.BicategoryLike.AtomIso → m Mathlib.Tactic.BicategoryLike.Atom} →
{invM : Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂}... | false |
CategoryTheory.Adjunction.mem_essImage_of_counit_isIso | Mathlib.CategoryTheory.Adjunction.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R) (A : D)
[CategoryTheory.IsIso (h.counit.app A)], L.essImage A | true |
Equiv.coe_fn_symm_mk | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} (f : α → β) (g : β → α) (l : Function.LeftInverse g f) (r : Function.RightInverse g f),
⇑{ toFun := f, invFun := g, left_inv := l, right_inv := r }.symm = g | true |
AlgebraicGeometry.SheafedSpace.GlueData.vPullbackConeIsLimit | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(D : AlgebraicGeometry.SheafedSpace.GlueData C) →
[inst_1 : CategoryTheory.Limits.HasLimits C] → (i j : D.J) → CategoryTheory.Limits.IsLimit (D.vPullbackCone i j) | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.gen_eq_preimage_restrict.match_1_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} (S : Set α) (motive : ↑S → Prop) (x : ↑S), (∀ (x : α) (hx : x ∈ S), motive ⟨x, hx⟩) → motive x | false |
Set.ssubset_union_left_iff._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, (s ⊂ s ∪ t) = ¬t ⊆ s | false |
_private.Init.Data.Range.Lemmas.0.Std.Legacy.Range.size_eq._proof_1_3 | Init.Data.Range.Lemmas | ∀ {i : ℕ} (r : Std.Legacy.Range),
i < r.stop →
0 < r.step →
¬i + r.step < r.stop → ¬(r.step ≤ r.stop - i + r.step - 1 ∧ r.stop - i + r.step - 1 ≤ r.step + r.step - 1) → False | false |
LinearMap.toAddMonoidHom_mulRight | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_14) {A : Type u_15} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] (a : A), ↑(LinearMap.mulRight R a) = AddMonoidHom.mulRight a | true |
Std.DHashMap.Raw.getD_modify_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {fallback : β k} {f : β k → β k},
m.WF → (m.modify k f).getD k fallback = (Option.map f (m.get? k)).getD fallback | true |
instLatticeTropical._proof_4 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : Lattice R] (a b : Tropical R), SemilatticeInf.inf a b ≤ a | false |
Nat.Subtype.ofNat._proof_1 | Mathlib.Logic.Denumerable | ∀ (s : Set ℕ) [Infinite ↑s], Nonempty ↑s | false |
_private.Std.Internal.Http.Data.URI.Basic.0.Std.Http.instReprRequestTarget.repr.match_1 | Std.Internal.Http.Data.URI.Basic | (motive : Std.Http.RequestTarget → Sort u_1) →
(x : Std.Http.RequestTarget) →
((a : Std.Http.URI.Path) → (a_1 : Option Std.Http.URI.Query) → motive (Std.Http.RequestTarget.originForm a a_1)) →
((a : Std.Http.URI) → motive (Std.Http.RequestTarget.absoluteForm a)) →
((a : Std.Http.URI.Authority) → mot... | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.nextArgHole?.match_1 | Lean.Elab.App | (motive : List Lean.Elab.Term.Arg → Sort u_1) →
(x : List Lean.Elab.Term.Arg) →
((stx : Lean.Syntax) →
(info : Lean.SourceInfo) →
(args : Array Lean.Syntax) →
(h : stx = Lean.Syntax.node info `Lean.Parser.Term.hole args) →
(tail : List Lean.Elab.Term.Arg) →
... | false |
PowerSeries.evalNegHom_X | Mathlib.RingTheory.PowerSeries.Basic | ∀ {A : Type u_2} [inst : CommRing A], PowerSeries.evalNegHom PowerSeries.X = -PowerSeries.X | true |
CategoryTheory.Presieve.regular.casesOn | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : C} →
{R : CategoryTheory.Presieve X} →
{motive : R.regular → Sort u} →
(t : R.regular) →
((single_epi :
∃ Y f,
(R = CategoryTheory.Presieve.ofArrows (fun x => Y) fun x =>... | false |
Int64.toInt16_add | Init.Data.SInt.Lemmas | ∀ (a b : Int64), (a + b).toInt16 = a.toInt16 + b.toInt16 | true |
GenContFract.nums_recurrence | Mathlib.Algebra.ContinuedFractions.ContinuantsRecurrence | ∀ {K : Type u_1} {g : GenContFract K} {n : ℕ} [inst : DivisionRing K] {gp : GenContFract.Pair K} {ppredA predA : K},
g.s.get? (n + 1) = some gp →
g.nums n = ppredA → g.nums (n + 1) = predA → g.nums (n + 2) = gp.b * predA + gp.a * ppredA | true |
CompHausLike.compHausLikeToTop_map | Mathlib.Topology.Category.CompHausLike.Basic | ∀ (P : TopCat → Prop) {X Y : CategoryTheory.InducedCategory TopCat CompHausLike.toTop} (f : X ⟶ Y),
(CompHausLike.compHausLikeToTop P).map f = f.hom | true |
Aesop.Frontend.Feature.ruleSets.inj | Aesop.Frontend.RuleExpr | ∀ {rs rs_1 : Aesop.Frontend.RuleSets},
Aesop.Frontend.Feature.ruleSets rs = Aesop.Frontend.Feature.ruleSets rs_1 → rs = rs_1 | true |
CategoryTheory.RetractArrow.ofRightLiftingProperty._proof_1 | Mathlib.CategoryTheory.MorphismProperty.RetractArgument | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {i : X ⟶ Y} {p : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp i p = f →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = CategoryTheory.CategoryStruct.comp i p | false |
_private.Lean.Level.0.Lean.Level.isZero.match_1 | Lean.Level | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) → (Unit → motive Lean.Level.zero) → ((x : Lean.Level) → motive x) → motive x | false |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.mem_cons._simp_1_2 | Std.Sat.CNF.Basic | ∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c) | false |
OrderIso.addLeft_toEquiv | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [inst_2 : AddLeftMono α] (a : α),
(OrderIso.addLeft a).toEquiv = Equiv.addLeft a | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.encodeCode.match_1.splitter | Mathlib.Computability.PartrecCode | (motive : Nat.Partrec.Code → Sort u_1) →
(x : Nat.Partrec.Code) →
(Unit → motive Nat.Partrec.Code.zero) →
(Unit → motive Nat.Partrec.Code.succ) →
(Unit → motive Nat.Partrec.Code.left) →
(Unit → motive Nat.Partrec.Code.right) →
((cf cg : Nat.Partrec.Code) → motive (cf.pair cg)) ... | true |
Nat.cast_card_eq_zero | Mathlib.GroupTheory.OrderOfElement | ∀ (R : Type u_6) [inst : AddGroupWithOne R] [inst_1 : Fintype R], ↑(Fintype.card R) = 0 | true |
OrderDual.instDivisionAddCommMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : SubtractionCommMonoid α],
OrderDual.instDivisionAddCommMonoid = { toSubtractionMonoid := OrderDual.instSubtractionMonoid, add_comm := ⋯ } | true |
SubAddAction.fixingAddSubgroupInsertEquiv.match_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_2} {α : Type u_1} [inst : AddGroup M] [inst_1 : AddAction M α] (a : α)
(s : Set ↥(SubAddAction.ofStabilizer M a)) (motive : ↑s → Prop) (x : ↑s),
(∀ (x : ↥(SubAddAction.ofStabilizer M a)) (hx : x ∈ s), motive ⟨x, hx⟩) → motive x | false |
WithZero.unzero_le_unzero._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LE α] {x y : WithZero α} (hx : x ≠ 0) (hy : y ≠ 0),
(WithZero.unzero hx ≤ WithZero.unzero hy) = (x ≤ y) | false |
Lean.Language.SnapshotLeaf.casesOn | Lean.Language.Basic | {motive : Lean.Language.SnapshotLeaf → Sort u} →
(t : Lean.Language.SnapshotLeaf) →
((toSnapshot : Lean.Language.Snapshot) → motive { toSnapshot := toSnapshot }) → motive t | false |
ContinuousAddMonoidHom.inl_toFun | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ (A : Type u_2) (B : Type u_3) [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] (i : A), (ContinuousAddMonoidHom.inl A B) i = (i, 0) | true |
Std.Tactic.BVDecide.LRAT.Action._sizeOf_1 | Std.Tactic.BVDecide.LRAT.Actions | {β : Type u} → {α : Type v} → [SizeOf β] → [SizeOf α] → Std.Tactic.BVDecide.LRAT.Action β α → ℕ | false |
Matroid.singleton_dep._simp_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.Dep {e} = M.IsLoop e | false |
Lean.Parser.Term.hole.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | true |
Function.fixedPoints | Mathlib.Dynamics.FixedPoints.Basic | {α : Type u} → (α → α) → Set α | true |
_private.Mathlib.RingTheory.Coprime.Lemmas.0.exists_sum_eq_one_iff_pairwise_coprime'._simp_1_1 | Mathlib.RingTheory.Coprime.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} (r : β → β → Prop) (f : α → β),
Pairwise (Function.onFun r fun x => f ↑x) = (↑s).Pairwise (Function.onFun r f) | false |
_private.Mathlib.RingTheory.Ideal.AssociatedPrime.Basic.0.associatedPrimes.eq_empty_of_subsingleton._simp_1_1 | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | false |
Nat.commute_cast | Mathlib.Data.Nat.Cast.Commute | ∀ {α : Type u_1} [inst : NonAssocSemiring α] (x : α) (n : ℕ), Commute x ↑n | true |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.equivPairAux._proof_5 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} (i j : ι), ¬i = j → ¬some j = some i | false |
ValuativeRel.instCommMonoidWithZeroValueGroupWithZero._proof_17 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (t : ValuativeRel.ValueGroupWithZero R), 0 * t = 0 | false |
Nat.add_eq_zero | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, m + n = 0 ↔ m = 0 ∧ n = 0 | true |
Std.DTreeMap.Internal.Impl.contains_maxKey | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {he : t.isEmpty = false}, Std.DTreeMap.Internal.Impl.contains (t.maxKey he) t = true | true |
_private.Mathlib.Analysis.Calculus.SmoothSeries.0.contDiff_tsum_of_eventually._simp_1_9 | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory.IsAddFundamentalDomain.preimage_of_equiv.match_1_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] {s : Set α} {f : β → α}
(x : β) (motive : (∃ g, g +ᵥ f x ∈ s) → Prop) (x_1 : ∃ g, g +ᵥ f x ∈ s),
(∀ (g : G) (hg : g +ᵥ f x ∈ s), motive ⋯) → motive x_1 | false |
QPF.IsUniform | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type u} → [q : QPF F] → Prop | true |
interior_sInter_subset | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] (S : Set (Set X)), interior (⋂₀ S) ⊆ ⋂ s ∈ S, interior s | true |
T2Space.recOn | Mathlib.Topology.Separation.Hausdorff | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : T2Space X → Sort u_1} →
(t : T2Space X) →
((t2 : Pairwise fun x y => ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v) → motive ⋯) → motive t | false |
CategoryTheory.Functor.opComp | Mathlib.CategoryTheory.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u_1} →
[inst_2 : CategoryTheory.Category.{v_1, u_1} E] →
(F : CategoryTheory.Functor C D) → (G : CategoryTheory.Functor D E) → (F.comp G).op ≅... | true |
Matrix.conjTranspose_eq_ofNat | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Semiring α] [inst_2 : StarRing α] {M : Matrix n n α}
{d : ℕ} [inst_3 : d.AtLeastTwo], M.conjTranspose = OfNat.ofNat d ↔ M = OfNat.ofNat d | true |
Nat.digits_zero | Mathlib.Data.Nat.Digits.Defs | ∀ (b : ℕ), b.digits 0 = [] | true |
Ordinal.iterate_le_nfp | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ (f : Ordinal.{u_1} → Ordinal.{u_1}) (a : Ordinal.{u_1}) (n : ℕ), f^[n] a ≤ Ordinal.nfp f a | true |
Lean.Firefox.instToJsonMicroseconds | Lean.Util.Profiler | Lean.ToJson Lean.Firefox.Microseconds | true |
Nat.findGreatest | Mathlib.Data.Nat.Find | (P : ℕ → Prop) → [DecidablePred P] → ℕ → ℕ | true |
Submodule.IsCompl.projection_apply_eq_zero_iff | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q) {x : E}, (Submodule.IsCompl.projection hpq) x = 0 ↔ x ∈ q | true |
WeierstrassCurve.Affine.Point.zero.sizeOf_spec | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} [inst_1 : SizeOf R],
sizeOf WeierstrassCurve.Affine.Point.zero = 1 | true |
CategoryTheory.PreZeroHypercover.Relation._sizeOf_inst | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{S : C} → (E : CategoryTheory.PreZeroHypercover S) → (i j : E.I₀) → [SizeOf C] → SizeOf (E.Relation i j) | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.ortho_ne_zero_of_not_collinear._proof_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
‖x‖ = 1 →
‖y‖ = 1 →
InnerProductGeometry.angle x y ≠ 0 → InnerProductGeometry.angle x y ≠ Real.pi → y = inner ℝ x y • x → False | false |
Subring.closure_singleton_intCast | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (n : ℤ), Subring.closure {↑n} = ⊥ | true |
SimpleGraph.mk' | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u} → { adj // (∀ (x y : V), adj x y = adj y x) ∧ ∀ (x : V), ¬adj x x = true } ↪ SimpleGraph V | true |
_private.Mathlib.Probability.Martingale.Upcrossing.0.MeasureTheory.mul_upcrossingsBefore_le._simp_1_7 | Mathlib.Probability.Martingale.Upcrossing | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
TwoSidedIdeal.mk._flat_ctor | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → RingCon R → TwoSidedIdeal R | false |
Set.ssubset_union_left_iff | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ⊂ s ∪ t ↔ ¬t ⊆ s | true |
Metric.continuousWithinAt_iff' | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : TopologicalSpace β] {f : β → α} {b : β} {s : Set β},
ContinuousWithinAt f s b ↔ ∀ ε > 0, ∀ᶠ (x : β) in nhdsWithin b s, dist (f x) (f b) < ε | true |
CategoryTheory.GrothendieckTopology.uliftYonedaEquiv_uliftYoneda_map | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] {X Y : C} (f : X ⟶ Y),
J.uliftYonedaEquiv ((CategoryTheory.GrothendieckTopology.uliftYoneda.{v', v, u} J).map f) = { down := f } | true |
List.kextract.eq_1 | Mathlib.Data.List.Sigma | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α), List.kextract a [] = (none, []) | true |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.Scheme.basicOpen_add_le._simp_1_2 | Mathlib.AlgebraicGeometry.Scheme | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | false |
Fin.shiftLeft._proof_1 | Init.Data.Fin.Basic | ∀ {n : ℕ}, ∀ a < n, ∀ (b : ℕ), a <<< b % n < n | false |
Set.coe_subset | Mathlib.Data.Set.Functor | ∀ {α : Type u} {β : Set α} {γ : Set ↑β},
(do
let a ← γ
pure ↑a) ⊆
β | true |
AList.mem_mk._simp_1 | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} {l : List (Sigma β)} {h : l.NodupKeys} {x : α},
(x ∈ { entries := l, nodupKeys := h }) = (x ∈ l.keys) | false |
Finsupp.instCeilDiv._proof_3 | Mathlib.Algebra.Order.Floor.Div | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α]
[inst_2 : AddCommMonoid β] [inst_3 : PartialOrder β] [inst_4 : SMulZeroClass α β] [inst_5 : CeilDiv α β] (a : α),
Finsupp.mapRange (fun x => x ⌈/⌉ a) ⋯ 0 = 0 | false |
Path.reparam_id | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (γ : Path x y), γ.reparam id ⋯ ⋯ ⋯ = γ | true |
Std.Rii.recOn | Init.Data.Range.Polymorphic.PRange | {α : Type u} → {motive : Std.Rii α → Sort u_1} → (t : Std.Rii α) → motive *...* → motive t | false |
List.findIdx?_eq_findSome?_zipIdx.match_1 | Init.Data.List.Find | {α : Type u_1} → (motive : α × ℕ → Sort u_2) → (x : α × ℕ) → ((a : α) → (i : ℕ) → motive (a, i)) → motive x | false |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Basic.0.CategoryTheory.Pretriangulated.shiftFunctorCompIsoId_op_hom_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (n m : ℤ), n + m = 0 → m + n = 0 | false |
Std.Time.Fraction.truncated.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{digits digits' : ℕ} →
Std.Time.Fraction.truncated digits = Std.Time.Fraction.truncated digits' → (digits = digits' → P) → P | false |
FirstOrder.Language.Term.listEncode._sunfold | Mathlib.ModelTheory.Encoding | {L : FirstOrder.Language} → {α : Type u'} → L.Term α → List (α ⊕ (i : ℕ) × L.Functions i) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.