1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.Surjective.rightDistribClass
File: Mathlib/Algebra/Ring/InjSurj.lean

tactic: simp only [← add, ← mul, right_distrib]
state_before: α : Type u_1
β : Type u_2
inst✝¹³ : Zero β
inst✝¹² : One β
inst✝¹¹ : Add β
inst✝¹⁰ : Mul β
inst✝⁹ : Neg β
inst✝⁸ : Sub β
inst✝⁷ : SMul ℕ β
inst✝⁶ : SMul ℤ β
inst✝⁵ : Pow β ℕ
inst✝⁴ : NatCast β
inst✝³ : IntCast β
f : α → β
hf : Surjective f
inst✝² : Mul α
inst✝¹ : Add α
inst✝ : RightDistribClass α
add : ∀ (x y : α), f (x + y) = f x + f y
mul : ∀ (x y : α), f (x * y) = f x * f y
x y z : α
⊢ (f x + f y) * f z = f x * f z + f y * f z
state_after: no goals
Theorem: CliffordAlgebra.evenOdd_comap_reverse
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

tactic: rw [← submodule_map_reverse_eq_comap, evenOdd_map_reverse]
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
n : ZMod 2
⊢ Submodule.comap reverse (evenOdd Q n) = evenOdd Q n
state_after: no goals
Theorem: Nat.two_pow_and
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [mul_comm, land_comm, and_two_pow]
state_before: n i : ℕ
⊢ 2 ^ i &&& n = 2 ^ i * (n.testBit i).toNat
state_after: no goals
Theorem: Polynomial.card_rootSet_eq_natDegree_iff_of_splits
File: Mathlib/FieldTheory/Separable.lean

tactic: simp_rw [rootSet_def, Finset.coe_sort_coe, Fintype.card_coe, natDegree_eq_card_roots h,
  Multiset.toFinset_card_eq_card_iff_nodup, nodup_aroots_iff_of_splits hf h]
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
hf : f ≠ 0
h : Splits (algebraMap F K) f
⊢ Fintype.card ↑(f.rootSet K) = f.natDegree ↔ f.Separable
state_after: no goals
Theorem: Left.inv_le_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_left a]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a⁻¹ ≤ 1 ↔ 1 ≤ a
state_after: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ ≤ a * 1 ↔ 1 ≤ a

tactic: simp
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ ≤ a * 1 ↔ 1 ≤ a
state_after: no goals
Theorem: Polynomial.not_isUnit_of_degree_pos
File: Mathlib/Algebra/Polynomial/RingDivision.lean

tactic: cases subsingleton_or_nontrivial R
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
⊢ ¬IsUnit p
state_after: case inl
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Subsingleton R
⊢ ¬IsUnit p

case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
⊢ ¬IsUnit p

tactic: intro h
state_before: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
⊢ ¬IsUnit p
state_after: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
h : IsUnit p
⊢ False

tactic: simp [degree_eq_zero_of_isUnit h] at hpl
state_before: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Nontrivial R
h : IsUnit p
⊢ False
state_after: no goals

tactic: simp [Subsingleton.elim p 0] at hpl
state_before: case inl
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hpl : 0 < p.degree
h✝ : Subsingleton R
⊢ ¬IsUnit p
state_after: no goals
Theorem: NNReal.lipschitzWith_sub
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [← isometry_subtype_coe.lipschitzWith_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
⊢ LipschitzWith 2 fun p => p.1 - p.2
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)

tactic: have : Isometry (Prod.map ((↑) : ℝ≥0 → ℝ) ((↑) : ℝ≥0 → ℝ)) :=
  isometry_subtype_coe.prod_map isometry_subtype_coe
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)

tactic: convert (((LipschitzWith.prod_fst.comp this.lipschitz).sub
  (LipschitzWith.prod_snd.comp this.lipschitz)).max_const 0)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)
state_after: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ 2 = 1 * 1 + 1 * 1

tactic: norm_num
state_before: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ 2 = 1 * 1 + 1 * 1
state_after: no goals
Theorem: ENat.toNat_eq_iff
File: Mathlib/Data/ENat/Basic.lean

tactic: induction m <;> simp [hn.symm]
state_before: m✝ n✝ m : ℕ∞
n : ℕ
hn : n ≠ 0
⊢ m.toNat = n ↔ m = ↑n
state_after: no goals
Theorem: Subalgebra.rank_sup_eq_rank_right_mul_rank_of_free
File: Mathlib/Algebra/Algebra/Subalgebra/Rank.lean

tactic: rw [sup_comm, rank_sup_eq_rank_left_mul_rank_of_free]
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
A B : Subalgebra R S
inst✝³ : Module.Free R ↥A
inst✝² : Module.Free R ↥B
inst✝¹ : Module.Free ↥A ↥(Algebra.adjoin ↥A ↑B)
inst✝ : Module.Free ↥B ↥(Algebra.adjoin ↥B ↑A)
⊢ Module.rank R ↥(A ⊔ B) = Module.rank R ↥B * Module.rank ↥B ↥(Algebra.adjoin ↥B ↑A)
state_after: no goals
Theorem: Real.rpow_natCast_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_mul hx, rpow_natCast]
state_before: x y z✝ : ℝ
n✝ : ℕ
hx : 0 ≤ x
n : ℕ
z : ℝ
⊢ x ^ (↑n * z) = (x ^ n) ^ z
state_after: no goals
Theorem: NormedAddGroupHom.opNorm_zero
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: rw [zero_mul]
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
x✝ : V₁
⊢ ‖0 x✝‖ = 0 * ‖x✝‖
state_after: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
x✝ : V₁
⊢ ‖0 x✝‖ = 0

tactic: exact norm_zero
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
x✝ : V₁
⊢ ‖0 x✝‖ = 0
state_after: no goals
Theorem: List.countP_go_eq_add
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: induction l generalizing n with
| nil => rfl
| cons head tail ih =>
  unfold countP.go
  rw [ih (n := n + 1), ih (n := n), ih (n := 1)]
  if h : p head then simp [h, Nat.add_assoc] else simp [h]
state_before: α : Type u_1
p q : α → Bool
n : Nat
l : List α
⊢ countP.go p l n = n + countP.go p l 0
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
p q : α → Bool
n : Nat
⊢ countP.go p [] n = n + countP.go p [] 0
state_after: no goals

tactic: unfold countP.go
state_before: case cons
α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
⊢ countP.go p (head :: tail) n = n + countP.go p (head :: tail) 0
state_after: case cons
α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
⊢ (bif p head then countP.go p tail (n + 1) else countP.go p tail n) =
    n + bif p head then countP.go p tail (0 + 1) else countP.go p tail 0

tactic: rw [ih (n := n + 1), ih (n := n), ih (n := 1)]
state_before: case cons
α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
⊢ (bif p head then countP.go p tail (n + 1) else countP.go p tail n) =
    n + bif p head then countP.go p tail (0 + 1) else countP.go p tail 0
state_after: case cons
α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
⊢ (bif p head then n + 1 + countP.go p tail 0 else n + countP.go p tail 0) =
    n + bif p head then 1 + countP.go p tail 0 else countP.go p tail 0

tactic: if h : p head then simp [h, Nat.add_assoc] else simp [h]
state_before: case cons
α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
⊢ (bif p head then n + 1 + countP.go p tail 0 else n + countP.go p tail 0) =
    n + bif p head then 1 + countP.go p tail 0 else countP.go p tail 0
state_after: no goals

tactic: simp [h, Nat.add_assoc]
state_before: α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
h : p head = true
⊢ (bif p head then n + 1 + countP.go p tail 0 else n + countP.go p tail 0) =
    n + bif p head then 1 + countP.go p tail 0 else countP.go p tail 0
state_after: no goals

tactic: simp [h]
state_before: α : Type u_1
p q : α → Bool
head : α
tail : List α
ih : ∀ {n : Nat}, countP.go p tail n = n + countP.go p tail 0
n : Nat
h : ¬p head = true
⊢ (bif p head then n + 1 + countP.go p tail 0 else n + countP.go p tail 0) =
    n + bif p head then 1 + countP.go p tail 0 else countP.go p tail 0
state_after: no goals
Theorem: Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: exact abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi h
state_before: θ ψ : Angle
h : 2 • θ + 2 • ψ = ↑π
⊢ |θ.cos| = |ψ.sin|
state_after: no goals
Theorem: InnerProductGeometry.angle_smul_left_of_neg
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [angle_comm, angle_smul_right_of_neg y x hr, angle_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
r : ℝ
hr : r < 0
⊢ angle (r • x) y = angle (-x) y
state_after: no goals
Theorem: Finsupp.lmapDomain_total
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: ext l
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
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
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), g (v i) = v' (f i)
⊢ Finsupp.total α' M' R v' ∘ₗ lmapDomain R R f = g ∘ₗ Finsupp.total α M R v
state_after: case h.h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
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
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), g (v i) = v' (f i)
l : α
⊢ ((Finsupp.total α' M' R v' ∘ₗ lmapDomain R R f) ∘ₗ lsingle l) 1 = ((g ∘ₗ Finsupp.total α M R v) ∘ₗ lsingle l) 1

tactic: simp [total_apply, Finsupp.sum_mapDomain_index, add_smul, h]
state_before: case h.h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
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
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), g (v i) = v' (f i)
l : α
⊢ ((Finsupp.total α' M' R v' ∘ₗ lmapDomain R R f) ∘ₗ lsingle l) 1 = ((g ∘ₗ Finsupp.total α M R v) ∘ₗ lsingle l) 1
state_after: no goals
Theorem: Nat.add_eq_min_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m + n = min m n ↔ m = 0 ∧ n = 0
state_after: no goals
Theorem: Ring.multichoose_one_right'
File: Mathlib/RingTheory/Binomial.lean

tactic: refine nsmul_right_injective (Nat.factorial 1) (Nat.factorial_ne_zero 1) ?_
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ multichoose r 1 = r ^ 1
state_after: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 1 • x) (multichoose r 1) = (fun x => Nat.factorial 1 • x) (r ^ 1)

tactic: simp only
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 1 • x) (multichoose r 1) = (fun x => Nat.factorial 1 • x) (r ^ 1)
state_after: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ Nat.factorial 1 • multichoose r 1 = Nat.factorial 1 • r ^ 1

tactic: rw [factorial_nsmul_multichoose_eq_ascPochhammer, ascPochhammer_one, smeval_X, Nat.factorial_one,
  one_smul]
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ Nat.factorial 1 • multichoose r 1 = Nat.factorial 1 • r ^ 1
state_after: no goals
Theorem: isCompactOperator_iff_exists_mem_nhds_isCompact_closure_image
File: Mathlib/Analysis/NormedSpace/CompactOperator.lean

tactic: rw [isCompactOperator_iff_exists_mem_nhds_image_subset_compact]
state_before: R₁ : Type u_1
R₂ : Type u_2
inst✝⁵ : Semiring R₁
inst✝⁴ : Semiring R₂
σ₁₂ : R₁ →+* R₂
M₁ : Type u_3
M₂ : Type u_4
inst✝³ : TopologicalSpace M₁
inst✝² : AddCommMonoid M₁
inst✝¹ : TopologicalSpace M₂
inst✝ : T2Space M₂
f : M₁ → M₂
⊢ IsCompactOperator f ↔ ∃ V ∈ 𝓝 0, IsCompact (closure (f '' V))
state_after: R₁ : Type u_1
R₂ : Type u_2
inst✝⁵ : Semiring R₁
inst✝⁴ : Semiring R₂
σ₁₂ : R₁ →+* R₂
M₁ : Type u_3
M₂ : Type u_4
inst✝³ : TopologicalSpace M₁
inst✝² : AddCommMonoid M₁
inst✝¹ : TopologicalSpace M₂
inst✝ : T2Space M₂
f : M₁ → M₂
⊢ (∃ V ∈ 𝓝 0, ∃ K, IsCompact K ∧ f '' V ⊆ K) ↔ ∃ V ∈ 𝓝 0, IsCompact (closure (f '' V))

tactic: exact
  ⟨fun ⟨V, hV, K, hK, hKV⟩ => ⟨V, hV, hK.closure_of_subset hKV⟩,
    fun ⟨V, hV, hVc⟩ => ⟨V, hV, closure (f '' V), hVc, subset_closure⟩⟩
state_before: R₁ : Type u_1
R₂ : Type u_2
inst✝⁵ : Semiring R₁
inst✝⁴ : Semiring R₂
σ₁₂ : R₁ →+* R₂
M₁ : Type u_3
M₂ : Type u_4
inst✝³ : TopologicalSpace M₁
inst✝² : AddCommMonoid M₁
inst✝¹ : TopologicalSpace M₂
inst✝ : T2Space M₂
f : M₁ → M₂
⊢ (∃ V ∈ 𝓝 0, ∃ K, IsCompact K ∧ f '' V ⊆ K) ↔ ∃ V ∈ 𝓝 0, IsCompact (closure (f '' V))
state_after: no goals
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (PullbackCone.unop (limit.cone (cospan f.op g.op))).ι.app WalkingSpan.right = pullback.snd.unop
state_after: no goals
Theorem: Set.Nat.encard_range
File: Mathlib/Data/Set/Card.lean

tactic: convert encard_coe_eq_coe_finsetCard (Finset.range k) using 1
state_before: α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ {i | i < k}.encard = ↑k
state_after: case h.e'_2
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ {i | i < k}.encard = (↑(Finset.range k)).encard

case h.e'_3
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ ↑k = ↑(Finset.range k).card

tactic: rw [Finset.card_range]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ ↑k = ↑(Finset.range k).card
state_after: no goals

tactic: rw [Finset.coe_range, Iio_def]
state_before: case h.e'_2
α : Type u_1
β : Type u_2
s t : Set α
k : ℕ
⊢ {i | i < k}.encard = (↑(Finset.range k)).encard
state_after: no goals
Theorem: Complex.integrable_pow_mul_norm_one_add_mul_inv
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: have := continuousOn_one_add_mul_inv <| mem_slitPlane_of_norm_lt_one hz
state_before: n : ℕ
z : ℂ
hz : ‖z‖ < 1
⊢ IntervalIntegrable (fun t => t ^ n * ‖(1 + ↑t * z)⁻¹‖) MeasureTheory.volume 0 1
state_after: n : ℕ
z : ℂ
hz : ‖z‖ < 1
this : ContinuousOn (fun t => (1 + t • z)⁻¹) (Set.Icc 0 1)
⊢ IntervalIntegrable (fun t => t ^ n * ‖(1 + ↑t * z)⁻¹‖) MeasureTheory.volume 0 1

tactic: rw [← Set.uIcc_of_le zero_le_one] at this
state_before: n : ℕ
z : ℂ
hz : ‖z‖ < 1
this : ContinuousOn (fun t => (1 + t • z)⁻¹) (Set.Icc 0 1)
⊢ IntervalIntegrable (fun t => t ^ n * ‖(1 + ↑t * z)⁻¹‖) MeasureTheory.volume 0 1
state_after: n : ℕ
z : ℂ
hz : ‖z‖ < 1
this : ContinuousOn (fun t => (1 + t • z)⁻¹) (Set.uIcc 0 1)
⊢ IntervalIntegrable (fun t => t ^ n * ‖(1 + ↑t * z)⁻¹‖) MeasureTheory.volume 0 1

tactic: exact ContinuousOn.intervalIntegrable (by fun_prop)
state_before: n : ℕ
z : ℂ
hz : ‖z‖ < 1
this : ContinuousOn (fun t => (1 + t • z)⁻¹) (Set.uIcc 0 1)
⊢ IntervalIntegrable (fun t => t ^ n * ‖(1 + ↑t * z)⁻¹‖) MeasureTheory.volume 0 1
state_after: no goals

tactic: fun_prop
state_before: n : ℕ
z : ℂ
hz : ‖z‖ < 1
this : ContinuousOn (fun t => (1 + t • z)⁻¹) (Set.uIcc 0 1)
⊢ ContinuousOn (fun t => t ^ n * ‖(1 + ↑t * z)⁻¹‖) (Set.uIcc 0 1)
state_after: no goals
Theorem: groupCohomology.mem_range_of_mem_twoCoboundaries
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

tactic: rcases h with ⟨x, rfl⟩
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
h : f ∈ twoCoboundaries A
⊢ (twoCocycles A).subtype f ∈ LinearMap.range (dOne A)
state_after: case intro
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : G → CoeSort.coe A
⊢ (twoCocycles A).subtype ((LinearMap.codRestrict (twoCocycles A) (dOne A) ⋯) x) ∈ LinearMap.range (dOne A)

tactic: exact ⟨x, rfl⟩
state_before: case intro
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : G → CoeSort.coe A
⊢ (twoCocycles A).subtype ((LinearMap.codRestrict (twoCocycles A) (dOne A) ⋯) x) ∈ LinearMap.range (dOne A)
state_after: no goals
Theorem: split_equalCharZero_mixedCharZero
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: by_cases h : ∃ p > 0, MixedCharZero R p
state_before: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
⊢ P
state_after: case pos
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ∃ p > 0, MixedCharZero R p
⊢ P

case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ¬∃ p > 0, MixedCharZero R p
⊢ P

tactic: rcases h with ⟨p, ⟨H, hp⟩⟩
state_before: case pos
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ∃ p > 0, MixedCharZero R p
⊢ P
state_after: case pos.intro.intro
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
H : p > 0
hp : MixedCharZero R p
⊢ P

tactic: rw [← MixedCharZero.reduce_to_p_prime] at h_mixed
state_before: case pos.intro.intro
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
H : p > 0
hp : MixedCharZero R p
⊢ P
state_after: case pos.intro.intro
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ p > 0, MixedCharZero R p → P
p : ℕ
H : p > 0
hp : MixedCharZero R p
⊢ P

tactic: exact h_mixed p H hp
state_before: case pos.intro.intro
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ p > 0, MixedCharZero R p → P
p : ℕ
H : p > 0
hp : MixedCharZero R p
⊢ P
state_after: no goals

tactic: apply h_equal
state_before: case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ¬∃ p > 0, MixedCharZero R p
⊢ P
state_after: case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ¬∃ p > 0, MixedCharZero R p
⊢ Algebra ℚ R

tactic: rw [← isEmpty_algebraRat_iff_mixedCharZero, not_isEmpty_iff] at h
state_before: case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ¬∃ p > 0, MixedCharZero R p
⊢ Algebra ℚ R
state_after: case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : Nonempty (Algebra ℚ R)
⊢ Algebra ℚ R

tactic: exact h.some
state_before: case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : Nonempty (Algebra ℚ R)
⊢ Algebra ℚ R
state_after: no goals
Theorem: absorbs_iff_eventually_nhds_zero
File: Mathlib/Analysis/LocallyConvex/Basic.lean

tactic: rw [← nhdsWithin_compl_singleton_sup_pure, Filter.eventually_sup, Filter.eventually_pure,
  ← absorbs_iff_eventually_nhdsWithin_zero, and_iff_left]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
h₀ : 0 ∈ s
⊢ Absorbs 𝕜 s t ↔ ∀ᶠ (c : 𝕜) in 𝓝 0, MapsTo (fun x => c • x) t s
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
h₀ : 0 ∈ s
⊢ MapsTo (fun x => 0 • x) t s

tactic: intro x _
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
h₀ : 0 ∈ s
⊢ MapsTo (fun x => 0 • x) t s
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x✝ : E
a b : 𝕜
h₀ : 0 ∈ s
x : E
a✝ : x ∈ t
⊢ (fun x => 0 • x) x ∈ s

tactic: simpa only [zero_smul]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x✝ : E
a b : 𝕜
h₀ : 0 ∈ s
x : E
a✝ : x ∈ t
⊢ (fun x => 0 • x) x ∈ s
state_after: no goals