tasksource/leandojo huggingface dataset:
Theorem: Finsupp.mem_supported'
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: haveI := Classical.decPred fun x : α => x ∈ s
state_before: α : Type u_1
M : Type u_2
N : Type ?u.51017
P : Type ?u.51020
R : Type u_3
S : Type ?u.51026
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set α
p : α →₀ M
⊢ p ∈ supported M R s ↔ ∀ (x : α), ¬x ∈ s → ↑p x = 0

tactic: simp [mem_supported, Set.subset_def, not_imp_comm]
state_before: α : Type u_1
M : Type u_2
N : Type ?u.51017
P : Type ?u.51020
R : Type u_3
S : Type ?u.51026
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set α
p : α →₀ M
this : DecidablePred fun x => x ∈ s
⊢ p ∈ supported M R s ↔ ∀ (x : α), ¬x ∈ s → ↑p x = 0
Theorem: Basis.ext_elem_iff
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp only [← FunLike.ext_iff, EmbeddingLike.apply_eq_iff_eq]
state_before: ι : Type u_3
ι' : Type ?u.207260
R : Type u_2
R₂ : Type ?u.207266
K : Type ?u.207269
M : Type u_1
M' : Type ?u.207275
M'' : Type ?u.207278
V : Type u
V' : Type ?u.207283
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x✝ : M
R₁ : Type ?u.207395
inst✝⁴ : Semiring R₁
σ : R →+* R₁
σ' : R₁ →+* R
inst✝³ : RingHomInvPair σ σ'
inst✝² : RingHomInvPair σ' σ
M₁ : Type ?u.207599
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
x y : M
⊢ x = y ↔ ∀ (i : ι), ↑(↑b.repr x) i = ↑(↑b.repr y) i
Theorem: AlgebraicTopology.DoldKan.map_hσ'
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

tactic: unfold hσ' hσ
state_before: C : Type u_4
inst✝⁴ : Category C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_1
inst✝² : Category D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : Functor.Additive G
X : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
⊢ hσ' q n m hnm = G.map (hσ' q n m hnm)

tactic: split_ifs
state_before: C : Type u_4
inst✝⁴ : Category C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_1
inst✝² : Category D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : Functor.Additive G
X : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
⊢ (if n < q then 0
      else (-1) ^ (n - q) • σ (((whiskering C D).obj G).obj X) { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : (((whiskering C D).obj G).obj X).obj [n + 1].op = (((whiskering C D).obj G).obj X).obj [m].op) =
    G.map
      ((if n < q then 0 else (-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
        eqToHom (_ : X.obj [n + 1].op = X.obj [m].op))

tactic: simp only [Functor.map_zero, zero_comp]
state_before: case inl
C : Type u_4
inst✝⁴ : Category C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_1
inst✝² : Category D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : Functor.Additive G
X : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
h✝ : n < q
⊢ 0 ≫ eqToHom (_ : (((whiskering C D).obj G).obj X).obj [n + 1].op = (((whiskering C D).obj G).obj X).obj [m].op) =
    G.map (0 ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op))

tactic: simp only [eqToHom_map, Functor.map_comp, Functor.map_zsmul]
state_before: case inr
C : Type u_4
inst✝⁴ : Category C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_1
inst✝² : Category D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : Functor.Additive G
X : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
h✝ : ¬n < q
⊢ ((-1) ^ (n - q) • σ (((whiskering C D).obj G).obj X) { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : (((whiskering C D).obj G).obj X).obj [n + 1].op = (((whiskering C D).obj G).obj X).obj [m].op) =
    G.map
      (((-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
        eqToHom (_ : X.obj [n + 1].op = X.obj [m].op))

tactic: rfl
state_before: case inr
C : Type u_4
inst✝⁴ : Category C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_1
inst✝² : Category D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : Functor.Additive G
X : SimplicialObject C
q n m : ℕ
hnm : ComplexShape.Rel c m n
h✝ : ¬n < q
⊢ ((-1) ^ (n - q) • σ (((whiskering C D).obj G).obj X) { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : (((whiskering C D).obj G).obj X).obj [n + 1].op = (((whiskering C D).obj G).obj X).obj [m].op) =
    ((-1) ^ (n - q) • G.map (σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) })) ≫
      eqToHom (_ : G.obj (X.obj [n + 1].op) = G.obj (HomologicalComplex.X K[X] m))
Theorem: ENNReal.div_eq_div_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [eq_div_iff ha ha']
state_before: α : Type ?u.310915
β : Type ?u.310918
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ c / b = d / a ↔ a * c = b * d

tactic: conv_rhs => rw [eq_comm]
state_before: α : Type ?u.310915
β : Type ?u.310918
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ a * (c / b) = d ↔ a * c = b * d

tactic: rw [← eq_div_iff hb hb', mul_div_assoc, eq_comm]
state_before: α : Type ?u.310915
β : Type ?u.310918
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
ha' : a ≠ ⊤
hb : b ≠ 0
hb' : b ≠ ⊤
⊢ a * (c / b) = d ↔ b * d = a * c
Theorem: Composition.invEmbedding_comp
File: Mathlib/Combinatorics/Composition.lean

tactic: simp_rw [coe_invEmbedding, index_embedding, coe_embedding, add_tsub_cancel_left]
state_before: n : ℕ
c : Composition n
i : Fin (length c)
j : Fin (blocksFun c i)
⊢ ↑(invEmbedding c (↑(embedding c i) j)) = ↑j
Theorem: MonoidAlgebra.Submodule.exists_isCompl
File: Mathlib/RepresentationTheory/Maschke.lean

tactic: have : IsScalarTower k (MonoidAlgebra k G) p := p.isScalarTower'
state_before: k : Type u
inst✝¹¹ : Field k
G : Type u
inst✝¹⁰ : Fintype G
inst✝⁹ : Invertible ↑(Fintype.card G)
inst✝⁸ : Group G
V : Type u
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module k V
inst✝⁵ : Module (MonoidAlgebra k G) V
inst✝⁴ : IsScalarTower k (MonoidAlgebra k G) V
W : Type u
inst✝³ : AddCommGroup W
inst✝² : Module k W
inst✝¹ : Module (MonoidAlgebra k G) W
inst✝ : IsScalarTower k (MonoidAlgebra k G) W
p : Submodule (MonoidAlgebra k G) V
⊢ ∃ q, IsCompl p q

tactic: rcases MonoidAlgebra.exists_leftInverse_of_injective p.subtype p.ker_subtype with ⟨f, hf⟩
state_before: k : Type u
inst✝¹¹ : Field k
G : Type u
inst✝¹⁰ : Fintype G
inst✝⁹ : Invertible ↑(Fintype.card G)
inst✝⁸ : Group G
V : Type u
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module k V
inst✝⁵ : Module (MonoidAlgebra k G) V
inst✝⁴ : IsScalarTower k (MonoidAlgebra k G) V
W : Type u
inst✝³ : AddCommGroup W
inst✝² : Module k W
inst✝¹ : Module (MonoidAlgebra k G) W
inst✝ : IsScalarTower k (MonoidAlgebra k G) W
p : Submodule (MonoidAlgebra k G) V
this : IsScalarTower k (MonoidAlgebra k G) { x // x ∈ p }
⊢ ∃ q, IsCompl p q

tactic: refine ⟨LinearMap.ker f, LinearMap.isCompl_of_proj ?_⟩
state_before: case intro
k : Type u
inst✝¹¹ : Field k
G : Type u
inst✝¹⁰ : Fintype G
inst✝⁹ : Invertible ↑(Fintype.card G)
inst✝⁸ : Group G
V : Type u
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module k V
inst✝⁵ : Module (MonoidAlgebra k G) V
inst✝⁴ : IsScalarTower k (MonoidAlgebra k G) V
W : Type u
inst✝³ : AddCommGroup W
inst✝² : Module k W
inst✝¹ : Module (MonoidAlgebra k G) W
inst✝ : IsScalarTower k (MonoidAlgebra k G) W
p : Submodule (MonoidAlgebra k G) V
this : IsScalarTower k (MonoidAlgebra k G) { x // x ∈ p }
f : V →ₗ[MonoidAlgebra k G] { x // x ∈ p }
hf : LinearMap.comp f (Submodule.subtype p) = LinearMap.id
⊢ ∃ q, IsCompl p q

tactic: exact FunLike.congr_fun hf
state_before: case intro
k : Type u
inst✝¹¹ : Field k
G : Type u
inst✝¹⁰ : Fintype G
inst✝⁹ : Invertible ↑(Fintype.card G)
inst✝⁸ : Group G
V : Type u
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module k V
inst✝⁵ : Module (MonoidAlgebra k G) V
inst✝⁴ : IsScalarTower k (MonoidAlgebra k G) V
W : Type u
inst✝³ : AddCommGroup W
inst✝² : Module k W
inst✝¹ : Module (MonoidAlgebra k G) W
inst✝ : IsScalarTower k (MonoidAlgebra k G) W
p : Submodule (MonoidAlgebra k G) V
this : IsScalarTower k (MonoidAlgebra k G) { x // x ∈ p }
f : V →ₗ[MonoidAlgebra k G] { x // x ∈ p }
hf : LinearMap.comp f (Submodule.subtype p) = LinearMap.id
⊢ ∀ (x : { x // x ∈ p }), ↑f ↑x = x
Theorem: IsLocalization.card_le
File: Mathlib/RingTheory/Localization/Cardinality.lean

tactic: cases fintypeOrInfinite R
state_before: R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
⊢ (#L) ≤ (#R)

tactic: erw [← Cardinal.mul_eq_self <| Cardinal.aleph0_le_mk R]
state_before: case inr
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
⊢ (#L) ≤ (#R)

tactic: set f : R × R → L := fun aa => IsLocalization.mk' _ aa.1 (if h : aa.2 ∈ S then ⟨aa.2, h⟩ else 1)
state_before: case inr
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
⊢ (#L) ≤ (#R) * (#R)

tactic: refine' @Cardinal.mk_le_of_surjective _ _ f fun a => _
state_before: case inr
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
f : R × R → L := fun aa => mk' L aa.fst (if h : aa.snd ∈ S then { val := aa.snd, property := h } else 1)
⊢ (#L) ≤ (#R) * (#R)

tactic: obtain ⟨x, y, h⟩ := IsLocalization.mk'_surjective S a
state_before: case inr
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
f : R × R → L := fun aa => mk' L aa.fst (if h : aa.snd ∈ S then { val := aa.snd, property := h } else 1)
a : L
⊢ ∃ a_1, f a_1 = a

tactic: use (x, y)
state_before: case inr.intro.intro
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
f : R × R → L := fun aa => mk' L aa.fst (if h : aa.snd ∈ S then { val := aa.snd, property := h } else 1)
a : L
x : R
y : { x // x ∈ S }
h : mk' L x y = a
⊢ ∃ a_1, f a_1 = a

tactic: dsimp
state_before: case inr.intro.intro
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
f : R × R → L := fun aa => mk' L aa.fst (if h : aa.snd ∈ S then { val := aa.snd, property := h } else 1)
a : L
x : R
y : { x // x ∈ S }
h : mk' L x y = a
⊢ f (x, ↑y) = a

tactic: rwa [dif_pos <| show ↑y ∈ S from y.2, SetLike.eta]
state_before: case inr.intro.intro
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Infinite R
f : R × R → L := fun aa => mk' L aa.fst (if h : aa.snd ∈ S then { val := aa.snd, property := h } else 1)
a : L
x : R
y : { x // x ∈ S }
h : mk' L x y = a
⊢ mk' L x (if h : ↑y ∈ S then { val := ↑y, property := h } else 1) = a

tactic: exact Cardinal.mk_le_of_surjective (IsArtinianRing.localization_surjective S _)
state_before: case inl
R : Type u
inst✝³ : CommRing R
S : Submonoid R
L : Type u
inst✝² : CommRing L
inst✝¹ : Algebra R L
inst✝ : IsLocalization S L
val✝ : Fintype R
⊢ (#L) ≤ (#R)
Theorem: Matrix.trace_kroneckerMapBilinear
File: Mathlib/Data/Matrix/Kronecker.lean

tactic: simp_rw [Matrix.trace, Matrix.diag, kroneckerMapBilinear_apply_apply, LinearMap.map_sum₂,
  map_sum, ← Finset.univ_product_univ, Finset.sum_product, kroneckerMap_apply]
state_before: R : Type u_1
α : Type u_4
α' : Type ?u.49841
β : Type u_5
β' : Type ?u.49847
γ : Type u_6
γ' : Type ?u.49853
l : Type ?u.49856
m : Type u_2
n : Type u_3
p : Type ?u.49865
q : Type ?u.49868
r : Type ?u.49871
l' : Type ?u.49874
m' : Type ?u.49877
n' : Type ?u.49880
p' : Type ?u.49883
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : AddCommMonoid α
inst✝⁴ : AddCommMonoid β
inst✝³ : AddCommMonoid γ
inst✝² : Module R α
inst✝¹ : Module R β
inst✝ : Module R γ
f : α →ₗ[R] β →ₗ[R] γ
A : Matrix m m α
B : Matrix n n β
⊢ trace (↑(↑(kroneckerMapBilinear f) A) B) = ↑(↑f (trace A)) (trace B)
Theorem: CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_hom
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
j : J
⊢ s.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).hom = w.hom.app j ≫ t.ι.app j
Theorem: CategoryTheory.Idempotents.Karoubi.decomp_p
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: ext
state_before: C : Type u_1
inst✝ : Category C
P : Karoubi C
⊢ (toKaroubi C).map P.p = decompId_p P ≫ decompId_i P

tactic: simp only [comp_f, decompId_p_f, decompId_i_f, P.idem, toKaroubi_map_f]
state_before: case h
C : Type u_1
inst✝ : Category C
P : Karoubi C
⊢ ((toKaroubi C).map P.p).f = (decompId_p P ≫ decompId_i P).f
Theorem: ENNReal.continuous_pow
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: induction' n with n IH
state_before: α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
⊢ Continuous fun a => a ^ n

tactic: simp_rw [Nat.succ_eq_add_one, pow_add, pow_one, continuous_iff_continuousAt]
state_before: case succ
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
⊢ Continuous fun a => a ^ Nat.succ n

tactic: intro x
state_before: case succ
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
⊢ ∀ (x : ℝ≥0∞), ContinuousAt (fun a => a ^ n * a) x

tactic: refine' ENNReal.Tendsto.mul (IH.tendsto _) _ tendsto_id _ <;> by_cases H : x = 0
state_before: case succ
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
x : ℝ≥0∞
⊢ ContinuousAt (fun a => a ^ n * a) x

tactic: simp [continuous_const]
state_before: case zero
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ Continuous fun a => a ^ Nat.zero

tactic: simp only [H, zero_ne_top, Ne.def, or_true_iff, not_false_iff]
state_before: case pos
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
x : ℝ≥0∞
H : x = 0
⊢ x ^ n ≠ 0 ∨ x ≠ ⊤

tactic: exact Or.inl fun h => H (pow_eq_zero h)
state_before: case neg
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
x : ℝ≥0∞
H : ¬x = 0
⊢ x ^ n ≠ 0 ∨ x ≠ ⊤

tactic: simp only [H, pow_eq_top_iff, zero_ne_top, false_or_iff, eq_self_iff_true, not_true, Ne.def,
  not_false_iff, false_and_iff]
state_before: case pos
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
x : ℝ≥0∞
H : x = 0
⊢ x ≠ 0 ∨ x ^ n ≠ ⊤

tactic: simp only [H, true_or_iff, Ne.def, not_false_iff]
state_before: case neg
α : Type ?u.105152
β : Type ?u.105155
γ : Type ?u.105158
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
n : ℕ
IH : Continuous fun a => a ^ n
x : ℝ≥0∞
H : ¬x = 0
⊢ x ≠ 0 ∨ x ^ n ≠ ⊤
Theorem: Prod.ext_iff
File: Mathlib/Data/Prod/Basic.lean

tactic: rw [← @mk.eta _ _ p, ← @mk.eta _ _ q, mk.inj_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3004
δ : Type ?u.3007
p q : α × β
⊢ p = q ↔ p.fst = q.fst ∧ p.snd = q.snd
Theorem: MeasureTheory.Measure.mapₗ_congr
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172555
δ : Type ?u.172558
ι : Type ?u.172561
R : Type ?u.172564
R' : Type ?u.172567
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f g : α → β
hf : Measurable f
hg : Measurable g
h : f =ᶠ[ae μ] g
⊢ ↑(mapₗ f) μ = ↑(mapₗ g) μ

tactic: simpa only [mapₗ, hf, hg, hs, dif_pos, liftLinear_apply, OuterMeasure.map_apply]
  using measure_congr (h.preimage s)
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.172555
δ : Type ?u.172558
ι : Type ?u.172561
R : Type ?u.172564
R' : Type ?u.172567
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f g : α → β
hf : Measurable f
hg : Measurable g
h : f =ᶠ[ae μ] g
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑(mapₗ f) μ) s = ↑↑(↑(mapₗ g) μ) s
Theorem: gold_sub_goldConj
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [goldenRatio, goldenConj]
state_before: ⊢ φ - ψ = sqrt 5

tactic: ring
state_before: ⊢ (1 + sqrt 5) / 2 - (1 - sqrt 5) / 2 = sqrt 5
Theorem: PowerSeries.coeff_def
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: erw [coeff, ← h, ← Finsupp.unique_single s]
state_before: R : Type u_1
inst✝ : Semiring R
s : Unit →₀ ℕ
n : ℕ
h : ↑s () = n
⊢ coeff R n = MvPowerSeries.coeff R s
Theorem: Real.strictAntiOn_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rintro x (hx : x < 0) y (hy : y < 0) hxy
state_before: b x y : ℝ
hb : 1 < b
⊢ StrictAntiOn (logb b) (Iio 0)

tactic: rw [← logb_abs y, ← logb_abs x]
state_before: b x✝ y✝ : ℝ
hb : 1 < b
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b y < logb b x

tactic: refine' logb_lt_logb hb (abs_pos.2 hy.ne) _
state_before: b x✝ y✝ : ℝ
hb : 1 < b
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b (abs y) < logb b (abs x)

tactic: rwa [abs_of_neg hy, abs_of_neg hx, neg_lt_neg_iff]
state_before: b x✝ y✝ : ℝ
hb : 1 < b
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ abs y < abs x
Theorem: MonoidWithZeroHom.cancel_left
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [← MonoidWithZeroHom.comp_apply, h,
MonoidWithZeroHom.comp_apply]
state_before: α : Type ?u.170280
β : Type ?u.170283
M : Type u_1
N : Type u_2
P : Type u_3
G : Type ?u.170295
H : Type ?u.170298
F : Type ?u.170301
inst✝² : MulZeroOneClass M
inst✝¹ : MulZeroOneClass N
inst✝ : MulZeroOneClass P
g : N →*₀ P
f₁ f₂ : M →*₀ N
hg : Function.Injective ↑g
h : comp g f₁ = comp g f₂
x : M
⊢ ↑g (↑f₁ x) = ↑g (↑f₂ x)
Theorem: Real.smoothTransition.projIcc
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: refine' congr_fun (IccExtend_eq_self zero_le_one smoothTransition (fun x hx => _) fun x hx => _) x
state_before: x : ℝ
⊢ smoothTransition ↑(projIcc 0 1 (_ : 0 ≤ 1) x) = smoothTransition x

tactic: rw [smoothTransition.zero, zero_of_nonpos hx.le]
state_before: case refine'_1
x✝ x : ℝ
hx : x < 0
⊢ smoothTransition x = smoothTransition 0

tactic: rw [smoothTransition.one, one_of_one_le hx.le]
state_before: case refine'_2
x✝ x : ℝ
hx : 1 < x
⊢ smoothTransition x = smoothTransition 1
Theorem: MeasureTheory.SimpleFunc.negPart_map_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [negPart]
state_before: α : Type u_1
E : Type ?u.93564
F : Type ?u.93567
𝕜 : Type ?u.93570
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
⊢ map norm (negPart f) = negPart f

tactic: exact posPart_map_norm _
state_before: α : Type u_1
E : Type ?u.93564
F : Type ?u.93567
𝕜 : Type ?u.93570
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
⊢ map norm (posPart (-f)) = posPart (-f)
Theorem: Real.log_nat_eq_sum_factorization
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: x y : ℝ
n : ℕ
⊢ log ↑n = Finsupp.sum (Nat.factorization n) fun p t => ↑t * log ↑p

tactic: simp
state_before: case inl
x y : ℝ
⊢ log ↑0 = Finsupp.sum (Nat.factorization 0) fun p t => ↑t * log ↑p

tactic: simp only [← log_pow, ← Nat.cast_pow]
state_before: case inr
x y : ℝ
n : ℕ
hn : n ≠ 0
⊢ log ↑n = Finsupp.sum (Nat.factorization n) fun p t => ↑t * log ↑p

tactic: rw [← Finsupp.log_prod, ← Nat.cast_finsupp_prod, Nat.factorization_prod_pow_eq_self hn]
state_before: case inr
x y : ℝ
n : ℕ
hn : n ≠ 0
⊢ log ↑n = Finsupp.sum (Nat.factorization n) fun p t => log ↑(p ^ t)

tactic: intro p hp
state_before: case inr.hg
x y : ℝ
n : ℕ
hn : n ≠ 0
⊢ ∀ (a : ℕ), ↑(a ^ ↑(Nat.factorization n) a) = 0 → ↑(Nat.factorization n) a = 0

tactic: rw [pow_eq_zero (Nat.cast_eq_zero.1 hp), Nat.factorization_zero_right]
state_before: case inr.hg
x y : ℝ
n : ℕ
hn : n ≠ 0
p : ℕ
hp : ↑(p ^ ↑(Nat.factorization n) p) = 0
⊢ ↑(Nat.factorization n) p = 0
Theorem: Real.volume_emetric_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: rcases eq_or_ne r ∞ with (rfl | hr)
state_before: ι : Type ?u.131283
inst✝ : Fintype ι
a : ℝ
r : ℝ≥0∞
⊢ ↑↑volume (EMetric.ball a r) = 2 * r

tactic: rw [Metric.emetric_ball_top, volume_univ, two_mul, _root_.top_add]
state_before: case inl
ι : Type ?u.131283
inst✝ : Fintype ι
a : ℝ
⊢ ↑↑volume (EMetric.ball a ⊤) = 2 * ⊤

tactic: lift r to ℝ≥0 using hr
state_before: case inr
ι : Type ?u.131283
inst✝ : Fintype ι
a : ℝ
r : ℝ≥0∞
hr : r ≠ ⊤
⊢ ↑↑volume (EMetric.ball a r) = 2 * r

tactic: rw [Metric.emetric_ball_nnreal, volume_ball, two_mul, ← NNReal.coe_add,
  ENNReal.ofReal_coe_nnreal, ENNReal.coe_add, two_mul]
state_before: case inr.intro
ι : Type ?u.131283
inst✝ : Fintype ι
a : ℝ
r : ℝ≥0
⊢ ↑↑volume (EMetric.ball a ↑r) = 2 * ↑r
Theorem: Nat.fib_bit0
File: Mathlib/Data/Nat/Fib.lean

tactic: rw [bit0_eq_two_mul, fib_two_mul]
state_before: n : ℕ
⊢ fib (bit0 n) = fib n * (2 * fib (n + 1) - fib n)
Theorem: Multiset.prod_sum
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: induction' s using Finset.induction_on with a t hat ih
state_before: ι✝ : Type ?u.943028
β : Type u
α✝ : Type v
γ : Type w
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β
inst✝¹ : DecidableEq α✝
α : Type u_1
ι : Type u_2
inst✝ : CommMonoid α
f : ι → Multiset α
s : Finset ι
⊢ prod (∑ x in s, f x) = ∏ x in s, prod (f x)

tactic: rw [Finset.sum_empty, Finset.prod_empty, Multiset.prod_zero]
state_before: case empty
ι✝ : Type ?u.943028
β : Type u
α✝ : Type v
γ : Type w
s s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β
inst✝¹ : DecidableEq α✝
α : Type u_1
ι : Type u_2
inst✝ : CommMonoid α
f : ι → Multiset α
⊢ prod (∑ x in ∅, f x) = ∏ x in ∅, prod (f x)

tactic: rw [Finset.sum_insert hat, Finset.prod_insert hat, Multiset.prod_add, ih]
state_before: case insert
ι✝ : Type ?u.943028
β : Type u
α✝ : Type v
γ : Type w
s s₁ s₂ : Finset α✝
a✝ : α✝
f✝ g : α✝ → β
inst✝¹ : DecidableEq α✝
α : Type u_1
ι : Type u_2
inst✝ : CommMonoid α
f : ι → Multiset α
a : ι
t : Finset ι
hat : ¬a ∈ t
ih : prod (∑ x in t, f x) = ∏ x in t, prod (f x)
⊢ prod (∑ x in insert a t, f x) = ∏ x in insert a t, prod (f x)
Theorem: StrictMono.pow_right'
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa
state_before: β : Type u_1
A : Type ?u.67813
G : Type ?u.67816
M : Type u_2
R : Type ?u.67822
inst✝⁴ : Monoid M
inst✝³ : Preorder M
inst✝² : Preorder β
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
f : β → M
hf : StrictMono f
x✝ : 1 ≠ 0
⊢ StrictMono fun a => f a ^ 1

tactic: simp_rw [pow_succ _ (n + 1)]
state_before: β : Type u_1
A : Type ?u.67813
G : Type ?u.67816
M : Type u_2
R : Type ?u.67822
inst✝⁴ : Monoid M
inst✝³ : Preorder M
inst✝² : Preorder β
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
f : β → M
hf : StrictMono f
n : ℕ
x✝ : Nat.succ (Nat.succ n) ≠ 0
⊢ StrictMono fun a => f a ^ Nat.succ (Nat.succ n)

tactic: exact hf.mul' (StrictMono.pow_right' hf n.succ_ne_zero)
state_before: β : Type u_1
A : Type ?u.67813
G : Type ?u.67816
M : Type u_2
R : Type ?u.67822
inst✝⁴ : Monoid M
inst✝³ : Preorder M
inst✝² : Preorder β
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
f : β → M
hf : StrictMono f
n : ℕ
x✝ : Nat.succ (Nat.succ n) ≠ 0
⊢ StrictMono fun a => f a * f a ^ (n + 1)