tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.prod_X_add_C_coeff
File: Mathlib/RingTheory/Polynomial/Vieta.lean

tactic: let s := Finset.univ.val.map fun i => (MvPolynomial.X i : MvPolynomial σ R)
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
h : k ≤ Fintype.card σ
⊢ Polynomial.coeff (∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i))) k = esymm σ R (Fintype.card σ - k)

tactic: have : Fintype.card σ = Multiset.card s := by
  rw [Multiset.card_map, ←Finset.card_univ, Finset.card_def]
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
h : k ≤ Fintype.card σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
⊢ Polynomial.coeff (∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i))) k = esymm σ R (Fintype.card σ - k)

tactic: rw [this] at h ⊢
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
h : k ≤ Fintype.card σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
this : Fintype.card σ = ↑Multiset.card s
⊢ Polynomial.coeff (∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i))) k = esymm σ R (Fintype.card σ - k)

tactic: rw [MvPolynomial.esymm_eq_multiset_esymm σ R, Finset.prod_eq_multiset_prod]
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
h : k ≤ ↑Multiset.card s
this : Fintype.card σ = ↑Multiset.card s
⊢ Polynomial.coeff (∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i))) k = esymm σ R (↑Multiset.card s - k)

tactic: convert Multiset.prod_X_add_C_coeff s h
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
h : k ≤ ↑Multiset.card s
this : Fintype.card σ = ↑Multiset.card s
⊢ Polynomial.coeff (Multiset.prod (Multiset.map (fun i => Polynomial.X + ↑Polynomial.C (X i)) univ.val)) k =
    Multiset.esymm (Multiset.map X univ.val) (↑Multiset.card s - k)

tactic: dsimp
state_before: case h.e'_2.h.e'_3.h.e'_3
R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
h : k ≤ ↑Multiset.card s
this : Fintype.card σ = ↑Multiset.card s
⊢ Multiset.map (fun i => Polynomial.X + ↑Polynomial.C (X i)) univ.val =
    Multiset.map (fun r => Polynomial.X + ↑Polynomial.C r) s

tactic: simp_rw [Multiset.map_map, Function.comp_apply]
state_before: case h.e'_2.h.e'_3.h.e'_3
R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
h : k ≤ ↑Multiset.card s
this : Fintype.card σ = ↑Multiset.card s
⊢ Multiset.map (fun i => Polynomial.X + ↑Polynomial.C (X i)) univ.val =
    Multiset.map (fun r => Polynomial.X + ↑Polynomial.C r) (Multiset.map (fun i => X i) univ.val)

tactic: rw [Multiset.card_map, ←Finset.card_univ, Finset.card_def]
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
k : ℕ
h : k ≤ Fintype.card σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
⊢ Fintype.card σ = ↑Multiset.card s
Theorem: Polynomial.rootMultiplicity_X_sub_C_self
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [rootMultiplicity_eq_multiplicity, dif_neg (X_sub_C_ne_zero x),
  multiplicity.get_multiplicity_self]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
x : R
⊢ rootMultiplicity x (X - ↑C x) = 1
Theorem: CategoryTheory.Biprod.isIso_inl_iff_isZero
File: Mathlib/CategoryTheory/Simple.lean

tactic: rw [biprod.isIso_inl_iff_id_eq_fst_comp_inl, ← biprod.total, add_right_eq_self]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ IsIso biprod.inl ↔ IsZero Y

tactic: constructor
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ biprod.snd ≫ biprod.inr = 0 ↔ IsZero Y

tactic: intro h
state_before: case mp
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ biprod.snd ≫ biprod.inr = 0 → IsZero Y

tactic: replace h := h =≫ biprod.snd
state_before: case mp
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
h : biprod.snd ≫ biprod.inr = 0
⊢ IsZero Y

tactic: simpa [← IsZero.iff_isSplitEpi_eq_zero (biprod.snd : X ⊞ Y ⟶ Y)] using h
state_before: case mp
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
h : (biprod.snd ≫ biprod.inr) ≫ biprod.snd = 0 ≫ biprod.snd
⊢ IsZero Y

tactic: intro h
state_before: case mpr
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ IsZero Y → biprod.snd ≫ biprod.inr = 0

tactic: rw [IsZero.iff_isSplitEpi_eq_zero (biprod.snd : X ⊞ Y ⟶ Y)] at h
state_before: case mpr
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
h : IsZero Y
⊢ biprod.snd ≫ biprod.inr = 0

tactic: rw [h, zero_comp]
state_before: case mpr
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
h : biprod.snd = 0
⊢ biprod.snd ≫ biprod.inr = 0
Theorem: differentiableWithinAt_inter
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp only [DifferentiableWithinAt, hasFDerivWithinAt_inter ht]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.304437
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.304532
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ht : t ∈ 𝓝 x
⊢ DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x
Theorem: Array.swapAt!_def
File: Std/Data/Array/Lemmas.lean

tactic: simp [swapAt!, h]
state_before: α : Type u_1
a : Array α
i : Nat
v : α
h : i < size a
⊢ swapAt! a i v = (a[i], set a { val := i, isLt := h } v)
Theorem: MvPolynomial.monomial_add_single
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [X_pow_eq_monomial, monomial_mul, mul_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ ↑(monomial (s + Finsupp.single n e)) a = ↑(monomial s) a * X n ^ e
Theorem: OmegaCompletePartialOrder.continuous_comp
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: dsimp [Continuous] at *
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : Continuous f
hgc : Continuous g
⊢ Continuous (OrderHom.comp g f)

tactic: intro
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : ∀ (c : Chain α), ↑f (ωSup c) = ωSup (map c f)
hgc : ∀ (c : Chain β), ↑g (ωSup c) = ωSup (map c g)
⊢ ∀ (c : Chain α), ↑g (↑f (ωSup c)) = ωSup (map c (OrderHom.comp g f))

tactic: rw [hfc, hgc, Chain.map_comp]
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : ∀ (c : Chain α), ↑f (ωSup c) = ωSup (map c f)
hgc : ∀ (c : Chain β), ↑g (ωSup c) = ωSup (map c g)
c✝ : Chain α
⊢ ↑g (↑f (ωSup c✝)) = ωSup (map c✝ (OrderHom.comp g f))
Theorem: DifferentiableOn.analyticAt
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: rcases nhds_basis_closedBall.mem_iff.1 hz with ⟨R, hR0, hRs⟩
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
s : Set ℂ
f : ℂ → E
z : ℂ
hd : DifferentiableOn ℂ f s
hz : s ∈ 𝓝 z
⊢ AnalyticAt ℂ f z

tactic: lift R to ℝ≥0 using hR0.le
state_before: case intro.intro
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
s : Set ℂ
f : ℂ → E
z : ℂ
hd : DifferentiableOn ℂ f s
hz : s ∈ 𝓝 z
R : ℝ
hR0 : 0 < R
hRs : closedBall z R ⊆ s
⊢ AnalyticAt ℂ f z

tactic: exact ((hd.mono hRs).hasFPowerSeriesOnBall hR0).analyticAt
state_before: case intro.intro.intro
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
s : Set ℂ
f : ℂ → E
z : ℂ
hd : DifferentiableOn ℂ f s
hz : s ∈ 𝓝 z
R : ℝ≥0
hR0 : 0 < ↑R
hRs : closedBall z ↑R ⊆ s
⊢ AnalyticAt ℂ f z
Theorem: Subalgebra.mvPolynomial_aeval_coe
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

tactic: convert aeval_algebraMap_apply A x p
state_before: R : Type u_1
A : Type u_2
B : Type ?u.261678
σ : Type u_3
inst✝² : CommSemiring R
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
S : Subalgebra R A
x : σ → { x // x ∈ S }
p : MvPolynomial σ R
⊢ ↑(aeval fun i => ↑(x i)) p = ↑(↑(aeval x) p)
Theorem: MeasureTheory.absolutelyContinuous_map_mul_right
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: refine' AbsolutelyContinuous.mk fun s hs => _
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun x => x * g) μ

tactic: rw [map_apply (measurable_mul_const g) hs, measure_mul_right_null]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
s : Set G
hs : MeasurableSet s
⊢ ↑↑(map (fun x => x * g) μ) s = 0 → ↑↑μ s = 0

tactic: exact id
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
s : Set G
hs : MeasurableSet s
⊢ ↑↑μ s = 0 → ↑↑μ s = 0
Theorem: FormalMultilinearSeries.hasFPowerSeriesOnBall
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rw [zero_add]
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
G : Type ?u.1057089
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f g : E → F
p✝ pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
inst✝ : CompleteSpace F
p : FormalMultilinearSeries 𝕜 E F
h : 0 < radius p
y✝ : E
hy : y✝ ∈ EMetric.ball 0 (radius p)
⊢ HasSum (fun n => ↑(p n) fun x => y✝) (FormalMultilinearSeries.sum p (0 + y✝))

tactic: exact p.hasSum hy
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type u_1
G : Type ?u.1057089
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f g : E → F
p✝ pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
inst✝ : CompleteSpace F
p : FormalMultilinearSeries 𝕜 E F
h : 0 < radius p
y✝ : E
hy : y✝ ∈ EMetric.ball 0 (radius p)
⊢ HasSum (fun n => ↑(p n) fun x => y✝) (FormalMultilinearSeries.sum p y✝)
Theorem: Polynomial.card_support_eq_one
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ card (support f) = 1 ↔ ∃ k x hx, f = ↑C x * X ^ k

tactic: obtain ⟨k, x, _, hx, rfl⟩ := card_support_eq.mp h
state_before: case refine'_1
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : card (support f) = 1
⊢ ∃ k x hx, f = ↑C x * X ^ k

tactic: exact ⟨k 0, x 0, hx 0, Fin.sum_univ_one _⟩
state_before: case refine'_1.intro.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
k : Fin 1 → ℕ
x : Fin 1 → R
w✝ : StrictMono k
hx : ∀ (i : Fin 1), x i ≠ 0
h : card (support (∑ i : Fin 1, ↑C (x i) * X ^ k i)) = 1
⊢ ∃ k_1 x_1 hx, ∑ i : Fin 1, ↑C (x i) * X ^ k i = ↑C x_1 * X ^ k_1

tactic: rintro ⟨k, x, hx, rfl⟩
state_before: case refine'_2
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ (∃ k x hx, f = ↑C x * X ^ k) → card (support f) = 1

tactic: rw [support_C_mul_X_pow k hx, card_singleton]
state_before: case refine'_2.intro.intro.intro
R : Type u_1
inst✝ : Semiring R
k : ℕ
x : R
hx : x ≠ 0
⊢ card (support (↑C x * X ^ k)) = 1
Theorem: Equiv.Perm.isCycle_of_prime_order'
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: classical exact isCycle_of_prime_order h1 (lt_of_le_of_lt σ.support.card_le_univ h2)
state_before: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
h2 : Fintype.card α < 2 * orderOf σ
⊢ IsCycle σ

tactic: exact isCycle_of_prime_order h1 (lt_of_le_of_lt σ.support.card_le_univ h2)
state_before: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (orderOf σ)
h2 : Fintype.card α < 2 * orderOf σ
⊢ IsCycle σ
Theorem: Stream'.interleave_even_odd
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h]
state_before: α : Type u
β : Type v
δ : Type w
s₁ s' s : Stream' α
h : s' = even s ⋈ odd s
⊢ head s' = head s ∧ (fun s' s => s' = even s ⋈ odd s) (tail s') (tail s)

tactic: constructor
state_before: α : Type u
β : Type v
δ : Type w
s₁ s' s : Stream' α
h : s' = even s ⋈ odd s
⊢ head (even s ⋈ odd s) = head s ∧ (fun s' s => s' = even s ⋈ odd s) (tail (even s ⋈ odd s)) (tail s)

tactic: rfl
state_before: case left
α : Type u
β : Type v
δ : Type w
s₁ s' s : Stream' α
h : s' = even s ⋈ odd s
⊢ head (even s ⋈ odd s) = head s

tactic: simp [odd_eq, odd_eq, tail_interleave, tail_even]
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁ s' s : Stream' α
h : s' = even s ⋈ odd s
⊢ (fun s' s => s' = even s ⋈ odd s) (tail (even s ⋈ odd s)) (tail s)
Theorem: Primrec.snd
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α✝ : Type ?u.42117
σ : Type ?u.42120
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.unpaired
      (fun z n =>
        Nat.casesOn n 0 fun y =>
          Nat.unpaired (fun z n => Nat.casesOn n 0 fun y => Nat.succ (Nat.unpair (Nat.pair z y)).snd)
            (Nat.pair (Nat.unpair (Nat.pair z y)).snd (encode (decode (Nat.unpair (Nat.pair z y)).fst))))
      (Nat.pair (Nat.unpair n).snd (encode (decode (Nat.unpair n).fst))) =
    encode (Option.map Prod.snd (decode n))

tactic: cases @decode α _ n.unpair.1 <;> simp
state_before: α✝ : Type ?u.42117
σ : Type ?u.42120
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.rec 0 (fun n_1 n_ih => Nat.rec 0 (fun n n_ih => Nat.succ n) (encode (decode (Nat.unpair n).snd)))
      (encode (decode (Nat.unpair n).fst)) =
    encode
      (Option.map Prod.snd
        (Option.bind (decode (Nat.unpair n).fst) fun a => Option.map (Prod.mk a) (decode (Nat.unpair n).snd)))

tactic: cases @decode β _ n.unpair.2 <;> simp
state_before: case some
α✝ : Type ?u.42117
σ : Type ?u.42120
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
val✝ : α
⊢ Nat.rec 0 (fun n n_ih => Nat.succ n) (encode (decode (Nat.unpair n).snd)) = encode (decode (Nat.unpair n).snd)
Theorem: Real.sqrt_zero
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp [sqrt]
state_before: x y : ℝ
⊢ sqrt 0 = 0
Theorem: Submonoid.LocalizationMap.sec_zero_fst
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [LocalizationMap.sec_spec', mul_zero]
state_before: M : Type u_1
inst✝² : CommMonoidWithZero M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoidWithZero N
P : Type ?u.3335552
inst✝ : CommMonoidWithZero P
f : LocalizationMap S N
⊢ ↑(toMap f) (sec f 0).fst = 0
Theorem: MonoidHom.inv_comp
File: Mathlib/Algebra/Hom/Group.lean

tactic: ext
state_before: α : Type ?u.240534
β : Type ?u.240537
M✝ : Type ?u.240540
N✝ : Type ?u.240543
P : Type ?u.240546
G : Type ?u.240549
H : Type ?u.240552
F : Type ?u.240555
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_1
N : Type u_2
A : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommGroup A
φ : N →* A
ψ : M →* N
⊢ comp φ⁻¹ ψ = (comp φ ψ)⁻¹

tactic: simp only [Function.comp_apply, inv_apply, coe_comp]
state_before: case h
α : Type ?u.240534
β : Type ?u.240537
M✝ : Type ?u.240540
N✝ : Type ?u.240543
P : Type ?u.240546
G : Type ?u.240549
H : Type ?u.240552
F : Type ?u.240555
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_1
N : Type u_2
A : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommGroup A
φ : N →* A
ψ : M →* N
x✝ : M
⊢ ↑(comp φ⁻¹ ψ) x✝ = ↑(comp φ ψ)⁻¹ x✝
Theorem: IsLocalizedModule.lift_comp
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: dsimp only [IsLocalizedModule.lift]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_4
M'' : Type u_3
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g✝ : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
⊢ LinearMap.comp (lift S f g h) f = g

tactic: rw [LinearMap.comp_assoc]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_4
M'' : Type u_3
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g✝ : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
⊢ LinearMap.comp (LinearMap.comp (LocalizedModule.lift S g h) ↑(LinearEquiv.symm (iso S f))) f = g

tactic: convert LocalizedModule.lift_comp S g h
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_4
M'' : Type u_3
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g✝ : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
⊢ LinearMap.comp (LocalizedModule.lift S g h) (LinearMap.comp (↑(LinearEquiv.symm (iso S f))) f) = g

tactic: exact iso_symm_comp _ _
state_before: case h.e'_2.h.e'_21
R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_4
M'' : Type u_3
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g✝ : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
g : M →ₗ[R] M''
h : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
⊢ LinearMap.comp (↑(LinearEquiv.symm (iso S f))) f = LocalizedModule.mkLinearMap S M
Theorem: Nat.one_lt_pow
File: Mathlib/Data/Nat/Pow.lean

tactic: rw [← one_pow n]
state_before: n m : ℕ
h₀ : 0 < n
h₁ : 1 < m
⊢ 1 < m ^ n

tactic: exact pow_lt_pow_of_lt_left h₁ h₀
state_before: n m : ℕ
h₀ : 0 < n
h₁ : 1 < m
⊢ 1 ^ n < m ^ n
Theorem: Part.mem_chain_of_mem_ωSup
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: simp [Part.ωSup] at h
state_before: α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h : a ∈ Part.ωSup c
⊢ some a ∈ c

tactic: split_ifs at h with h_1
state_before: α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h : a ∈ if h : ∃ a, some a ∈ c then some (choose h) else none
⊢ some a ∈ c

tactic: have h' := Classical.choose_spec h_1
state_before: case inl
α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (choose h_1)
⊢ some a ∈ c

tactic: rw [← eq_some_iff] at h
state_before: case inl
α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (choose h_1)
h' : some (choose h_1) ∈ c
⊢ some a ∈ c

tactic: rw [← h]
state_before: case inl
α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (choose h_1) = some a
h' : some (choose h_1) ∈ c
⊢ some a ∈ c

tactic: exact h'
state_before: case inl
α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (choose h_1) = some a
h' : some (choose h_1) ∈ c
⊢ some (choose h_1) ∈ c

tactic: rcases h with ⟨⟨⟩⟩
state_before: case inr
α : Type u
β : Type v
γ : Type ?u.14960
c : Chain (Part α)
a : α
h_1 : ¬∃ a, some a ∈ c
h : a ∈ none
⊢ some a ∈ c
Theorem: Real.cos_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw_mod_cast [one_div, ← inv_sqrt_one_add_tan_sq (cos_arctan_pos x), tan_arctan]
state_before: x : ℝ
⊢ cos (arctan x) = ↑1 / sqrt (↑1 + x ^ 2)
Theorem: Sum.elim_mul_mul
File: Mathlib/Data/Pi/Algebra.lean

tactic: ext x
state_before: I : Type u
α : Type u_2
β : Type u_3
γ : Type u_1
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Mul γ
⊢ Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b'

tactic: cases x <;> rfl
state_before: case h
I : Type u
α : Type u_2
β : Type u_3
γ : Type u_1
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Mul γ
x : α ⊕ β
⊢ Sum.elim (a * a') (b * b') x = (Sum.elim a b * Sum.elim a' b') x
Theorem: InnerProductGeometry.angle_self
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: unfold angle
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
hx : x ≠ 0
⊢ angle x x = 0

tactic: rw [← real_inner_self_eq_norm_mul_norm, div_self (inner_self_ne_zero.2 hx : ⟪x, x⟫ ≠ 0),
  Real.arccos_one]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
hx : x ≠ 0
⊢ arccos (inner x x / (‖x‖ * ‖x‖)) = 0
Theorem: CategoryTheory.Sheaf.Hom.mono_iff_presheaf_mono
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: infer_instance
state_before: C : Type u
inst✝⁷ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
F G : Sheaf J D
f : F ⟶ G
m : Mono f
⊢ Mono f.val

tactic: exact Sheaf.Hom.mono_of_presheaf_mono J D f
state_before: C : Type u
inst✝⁷ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ :
  ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
F G : Sheaf J D
f : F ⟶ G
m : Mono f.val
⊢ Mono f
Theorem: Finset.nnnorm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [NNReal.coe_prod]
state_before: α✝ : Type ?u.119341
β : Type ?u.119344
γ : Type ?u.119347
ι : Type u_2
inst✝¹ : SeminormedRing α✝
α : Type u_1
inst✝ : NormedCommRing α
s : Finset ι
hs : Finset.Nonempty s
f : ι → α
⊢ ∏ i in s, ‖f i‖ = (fun a => ↑a) (∏ i in s, ‖f i‖₊)