Loogle!

Result

Found 8 declarations mentioning Projectivization.map.

• Projectivization.map_id 📋 Mathlib.LinearAlgebra.Projectivization.Basic
  {K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] : Projectivization.map LinearMap.id ⋯ = id
• Projectivization.map 📋 Mathlib.LinearAlgebra.Projectivization.Basic
  {K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] {L : Type u_3} {W : Type u_4} [DivisionRing L] [AddCommGroup W] [Module L W] {σ : K →+* L} (f : V →ₛₗ[σ] W) (hf : Function.Injective ⇑f) : Projectivization K V → Projectivization L W
• Projectivization.map_injective 📋 Mathlib.LinearAlgebra.Projectivization.Basic
  {K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] {L : Type u_3} {W : Type u_4} [DivisionRing L] [AddCommGroup W] [Module L W] {σ : K →+* L} {τ : L →+* K} [RingHomInvPair σ τ] (f : V →ₛₗ[σ] W) (hf : Function.Injective ⇑f) : Function.Injective (Projectivization.map f hf)
• Projectivization.map.congr_simp 📋 Mathlib.LinearAlgebra.Projectivization.Basic
  {K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] {L : Type u_3} {W : Type u_4} [DivisionRing L] [AddCommGroup W] [Module L W] {σ : K →+* L} (f f✝ : V →ₛₗ[σ] W) (e_f : f = f✝) (hf : Function.Injective ⇑f) (a✝ a✝¹ : Projectivization K V) : a✝ = a✝¹ → Projectivization.map f hf a✝ = Projectivization.map f✝ ⋯ a✝¹
• Projectivization.map_comp 📋 Mathlib.LinearAlgebra.Projectivization.Basic
  {K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] {L : Type u_3} {W : Type u_4} [DivisionRing L] [AddCommGroup W] [Module L W] {F : Type u_5} {U : Type u_6} [DivisionRing F] [AddCommGroup U] [Module F U] {σ : K →+* L} {τ : L →+* F} {γ : K →+* F} [RingHomCompTriple σ τ γ] (f : V →ₛₗ[σ] W) (hf : Function.Injective ⇑f) (g : W →ₛₗ[τ] U) (hg : Function.Injective ⇑g) (hgf : Function.Injective ⇑(g ∘ₛₗ f) := ⋯) : Projectivization.map (g ∘ₛₗ f) hgf = Projectivization.map g hg ∘ Projectivization.map f hf
• Projectivization.map_mk 📋 Mathlib.LinearAlgebra.Projectivization.Basic
  {K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] {L : Type u_3} {W : Type u_4} [DivisionRing L] [AddCommGroup W] [Module L W] {σ : K →+* L} (f : V →ₛₗ[σ] W) (hf : Function.Injective ⇑f) (v : V) (hv : v ≠ 0) : Projectivization.map f hf (Projectivization.mk K v hv) = Projectivization.mk L (f v) ⋯
• Projectivization.smul_def 📋 Mathlib.LinearAlgebra.Projectivization.Action
  {G : Type u_1} {K : Type u_2} {V : Type u_3} [AddCommGroup V] [DivisionRing K] [Module K V] [Group G] [DistribMulAction G V] [SMulCommClass G K V] (g : G) (x : Projectivization K V) : SMul.smul g x = Projectivization.map ((DistribMulAction.toModuleEnd K V) g) ⋯ x
• Projectivization.generalLinearGroup_smul_def 📋 Mathlib.LinearAlgebra.Projectivization.Action
  {K : Type u_2} {V : Type u_3} [AddCommGroup V] [DivisionRing K] [Module K V] (g : LinearMap.GeneralLinearGroup K V) (x : Projectivization K V) : g • x = Projectivization.map ↑g.toLinearEquiv ⋯ x

About

Loogle searches Lean and Mathlib definitions and theorems.

You can use Loogle from within the Lean4 VSCode language extension using (by default) Ctrl-K Ctrl-S. You can also try the #loogle command from LeanSearchClient, the CLI version, the Loogle VS Code extension, the lean.nvim integration or the Zulip bot.

Usage

Loogle finds definitions and lemmas in various ways:

1. By constant:
   🔍 Real.sin
   finds all lemmas whose statement somehow mentions the sine function.

2. By lemma name substring:
   🔍 "differ"
   finds all lemmas that have "differ" somewhere in their lemma name.

3. By subexpression:
   🔍 _ * (_ ^ _)
   finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.

   The pattern can also be non-linear, as in
   🔍 Real.sqrt ?a * Real.sqrt ?a

   If the pattern has parameters, they are matched in any order. Both of these will find List.map:
   🔍 (?a -> ?b) -> List ?a -> List ?b
   🔍 List ?a -> (?a -> ?b) -> List ?b

4. By main conclusion:
   🔍 |- tsum _ = _ * tsum _
   finds all lemmas where the conclusion (the subexpression to the right of all → and ∀) has the given shape.

   As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
   🔍 |- _ < _ → tsum _ < tsum _
   will find tsum_lt_tsum even though the hypothesis f i < g i is not the last.

If you pass more than one such search filter, separated by commas Loogle will return lemmas which match all of them. The search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin and tsum, have "two" as a substring of the lemma name, include a product and a power somewhere in the type, and have a hypothesis of the form _ < _ (if there were any such lemmas). Metavariables (?a) are assigned independently in each filter.

The #lucky button will directly send you to the documentation of the first hit.

Source code

You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO.

This is Loogle revision ee8c038 serving mathlib revision 7a9e177