1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: commProb_def'
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: rw [commProb, card_comm_eq_card_conjClasses_mul_card, Nat.cast_mul, sq]
state_before: M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
⊢ commProb G = ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
state_after: M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)

tactic: by_cases h : (Nat.card G : ℚ) = 0
state_before: M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
state_after: case pos
M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
h : ↑(Nat.card G) = 0
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)

case neg
M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
h : ¬↑(Nat.card G) = 0
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)

tactic: rw [h, zero_mul, div_zero, div_zero]
state_before: case pos
M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
h : ↑(Nat.card G) = 0
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
state_after: no goals

tactic: exact mul_div_mul_right _ _ h
state_before: case neg
M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
h : ¬↑(Nat.card G) = 0
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
state_after: no goals
Theorem: Polynomial.support_C_mul_X_pow'
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: simpa only [C_mul_X_pow_eq_monomial] using support_monomial' n c
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
⊢ (C c * X ^ n).support ⊆ {n}
state_after: no goals
Theorem: IsCauSeq.cauchy₂
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: refine (hf _ (half_pos ε0)).imp fun i hi j ij k ik => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
⊢ ∃ i, ∀ j ≥ i, ∀ k ≥ i, abv (f j - f k) < ε
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f j - f k) < ε

tactic: rw [← add_halves ε]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f j - f k) < ε
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f j - f k) < ε / 2 + ε / 2

tactic: refine lt_of_le_of_lt (abv_sub_le abv _ _ _) (add_lt_add (hi _ ij) ?_)
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f j - f k) < ε / 2 + ε / 2
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f i - f k) < ε / 2

tactic: rw [abv_sub abv]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f i - f k) < ε / 2
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f k - f i) < ε / 2

tactic: exact hi _ ik
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : ℕ → β
hf : IsCauSeq abv f
ε : α
ε0 : 0 < ε
i : ℕ
hi : ∀ j ≥ i, abv (f j - f i) < ε / 2
j : ℕ
ij : j ≥ i
k : ℕ
ik : k ≥ i
⊢ abv (f k - f i) < ε / 2
state_after: no goals
Theorem: KaehlerDifferential.kerTotal_mkQ_single_smul
File: Mathlib/RingTheory/Kaehler/Basic.lean

tactic: letI : SMulZeroClass R S := inferInstance
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
r : R
x y : S
⊢ (y𝖣r • x) = r • y𝖣x
state_after: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
r : R
x y : S
this : SMulZeroClass R S := inferInstance
⊢ (y𝖣r • x) = r • y𝖣x

tactic: rw [Algebra.smul_def, KaehlerDifferential.kerTotal_mkQ_single_mul,
  KaehlerDifferential.kerTotal_mkQ_single_algebraMap, add_zero, ← LinearMap.map_smul_of_tower,
  Finsupp.smul_single, mul_comm, Algebra.smul_def]
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
r : R
x y : S
this : SMulZeroClass R S := inferInstance
⊢ (y𝖣r • x) = r • y𝖣x
state_after: no goals
Theorem: CategoryTheory.GradedObject.ι_mapMap
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: simp only [mapMap, ι_descMapObj]
state_before: I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝³ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j✝ : J
inst✝² : X.HasMap p
inst✝¹ : Y.HasMap p
inst✝ : Z.HasMap p
i : I
j : J
hij : p i = j
⊢ X.ιMapObj p i j hij ≫ mapMap φ p j = φ i ≫ Y.ιMapObj p i j hij
state_after: no goals
Theorem: bernsteinPolynomial.eq_zero_of_lt
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: simp [bernsteinPolynomial, Nat.choose_eq_zero_of_lt h]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : n < ν
⊢ bernsteinPolynomial R n ν = 0
state_after: no goals
Theorem: SimpleGraph.iInf_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [iInf]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
f : ι → SimpleGraph V
⊢ (⨅ i, f i).Adj a b ↔ (∀ (i : ι), (f i).Adj a b) ∧ a ≠ b
state_after: no goals
Theorem: Complex.circleIntegral_sub_inv_smul_of_differentiable_on_off_countable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: rw [← two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable
  hs hw hc hd, smul_inv_smul₀]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
s : Set ℂ
hs : s.Countable
hw : w ∈ ball c R
hc : ContinuousOn f (closedBall c R)
hd : ∀ x ∈ ball c R \ s, DifferentiableAt ℂ f x
⊢ (∮ (z : ℂ) in C(c, R), (z - w)⁻¹ • f z) = (2 * ↑π * I) • f w
state_after: case hc
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
s : Set ℂ
hs : s.Countable
hw : w ∈ ball c R
hc : ContinuousOn f (closedBall c R)
hd : ∀ x ∈ ball c R \ s, DifferentiableAt ℂ f x
⊢ 2 * ↑π * I ≠ 0

tactic: simp [Real.pi_ne_zero, I_ne_zero]
state_before: case hc
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
s : Set ℂ
hs : s.Countable
hw : w ∈ ball c R
hc : ContinuousOn f (closedBall c R)
hd : ∀ x ∈ ball c R \ s, DifferentiableAt ℂ f x
⊢ 2 * ↑π * I ≠ 0
state_after: no goals
Theorem: CategoryTheory.Bicategory.associator_naturality_right
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h h' : c ⟶ d
η : h ⟶ h'
⊢ (f ≫ g) ◁ η ≫ (α_ f g h').hom = (α_ f g h).hom ≫ f ◁ g ◁ η
state_after: no goals
Theorem: AbsoluteValue.map_units_int_smul
File: Mathlib/Data/Int/AbsoluteValue.lean

tactic: rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : LinearOrderedCommRing S
abv : AbsoluteValue R S
x : ℤˣ
y : R
⊢ abv (x • y) = abv y
state_after: no goals
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_comp
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [sub_def, Category.assoc, σ_comp, ← Category.assoc, prod.lift_map, sub_def]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
⊢ (f - g) ≫ h = f ≫ h - g ≫ h
state_after: no goals
Theorem: CategoryTheory.Limits.IsZero.of_epi_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Epi 0
⊢ 0 ≫ 𝟙 Y = 0 ≫ 0
state_after: no goals
Theorem: List.oldMapIdx_append
File: Mathlib/Data/List/Indexes.lean

tactic: intros f l e
state_before: α : Type u
β : Type v
⊢ ∀ (f : ℕ → α → β) (l : List α) (e : α), List.oldMapIdx f (l ++ [e]) = List.oldMapIdx f l ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdx f (l ++ [e]) = List.oldMapIdx f l ++ [f l.length e]

tactic: unfold List.oldMapIdx
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdx f (l ++ [e]) = List.oldMapIdx f l ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdxCore f 0 (l ++ [e]) = List.oldMapIdxCore f 0 l ++ [f l.length e]

tactic: rw [List.oldMapIdxCore_append f 0 l [e]]
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdxCore f 0 (l ++ [e]) = List.oldMapIdxCore f 0 l ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdxCore f 0 l ++ List.oldMapIdxCore f (0 + l.length) [e] = List.oldMapIdxCore f 0 l ++ [f l.length e]

tactic: simp only [Nat.zero_add]
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdxCore f 0 l ++ List.oldMapIdxCore f (0 + l.length) [e] = List.oldMapIdxCore f 0 l ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdxCore f 0 l ++ List.oldMapIdxCore f l.length [e] = List.oldMapIdxCore f 0 l ++ [f l.length e]

tactic: rfl
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ List.oldMapIdxCore f 0 l ++ List.oldMapIdxCore f l.length [e] = List.oldMapIdxCore f 0 l ++ [f l.length e]
state_after: no goals
Theorem: AddChar.to_mulShift_inj_of_isPrimitive
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

tactic: intro a b h
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ Function.Injective ψ.mulShift
state_after: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a = ψ.mulShift b
⊢ a = b

tactic: apply_fun fun x => x * mulShift ψ (-b) at h
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a = ψ.mulShift b
⊢ a = b
state_after: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a * ψ.mulShift (-b) = ψ.mulShift b * ψ.mulShift (-b)
⊢ a = b

tactic: simp only [mulShift_mul, mulShift_zero, add_right_neg, mulShift_apply] at h
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift a * ψ.mulShift (-b) = ψ.mulShift b * ψ.mulShift (-b)
⊢ a = b
state_after: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift (a + -b) = 1
⊢ a = b

tactic: simpa [← sub_eq_add_neg, sub_eq_zero] using (hψ . h)
state_before: R : Type u
inst✝¹ : CommRing R
R' : Type v
inst✝ : CommMonoid R'
ψ : AddChar R R'
hψ : ψ.IsPrimitive
a b : R
h : ψ.mulShift (a + -b) = 1
⊢ a = b
state_after: no goals
Theorem: FractionalIdeal.canonicalEquiv_mk0
File: Mathlib/RingTheory/ClassGroup.lean

tactic: simp only [FractionalIdeal.coe_mk0, FractionalIdeal.canonicalEquiv_coeIdeal]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹⁴ : CommRing R
inst✝¹³ : Field K
inst✝¹² : Field L
inst✝¹¹ : DecidableEq L
inst✝¹⁰ : Algebra R K
inst✝⁹ : IsFractionRing R K
inst✝⁸ : Algebra K L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra R L
inst✝⁵ : IsScalarTower R K L
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K' : Type u_4
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : ↥(Ideal R)⁰
⊢ (canonicalEquiv R⁰ K K') ↑((mk0 K) I) = ↑((mk0 K') I)
state_after: no goals
Theorem: Real.rpow_sub'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [sub_eq_add_neg] at h ⊢
state_before: x✝¹ y✝¹ z✝¹ w x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
h : y - z ≠ 0
⊢ x ^ (y - z) = x ^ y / x ^ z
state_after: x✝¹ y✝¹ z✝¹ w x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
h : y + -z ≠ 0
⊢ x ^ (y + -z) = x ^ y / x ^ z

tactic: simp only [rpow_add' hx h, rpow_neg hx, div_eq_mul_inv]
state_before: x✝¹ y✝¹ z✝¹ w x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
h : y + -z ≠ 0
⊢ x ^ (y + -z) = x ^ y / x ^ z
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.autMap_id
File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsGalois A
σ : Aut A
⊢ 𝟙 A ≫ (id σ).hom = σ.hom ≫ 𝟙 A
state_after: no goals
Theorem: Turing.BlankExtends.refl
File: Mathlib/Computability/TuringMachine.lean

tactic: simp
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
⊢ l = l ++ List.replicate 0 default
state_after: no goals
Theorem: RingQuot.Rel.smul
File: Mathlib/Algebra/RingQuot.lean

tactic: simp only [Algebra.smul_def, Rel.mul_right h]
state_before: R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : A → A → Prop
k : S
a b : A
h : Rel r a b
⊢ Rel r (k • a) (k • b)
state_after: no goals
Theorem: CategoryTheory.Limits.inv_prodComparison_map_snd
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp [IsIso.inv_comp_eq]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁵ : Category.{w, u₂} D
F : C ⥤ D
A A' B B' : C
inst✝⁴ : HasBinaryProduct A B
inst✝³ : HasBinaryProduct A' B'
inst✝² : HasBinaryProduct (F.obj A) (F.obj B)
inst✝¹ : HasBinaryProduct (F.obj A') (F.obj B')
inst✝ : IsIso (prodComparison F A B)
⊢ inv (prodComparison F A B) ≫ F.map prod.snd = prod.snd
state_after: no goals
Theorem: Real.surjOn_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [cos_zero, cos_pi] using intermediate_value_Icc' pi_pos.le continuous_cos.continuousOn
state_before: ⊢ SurjOn cos (Icc 0 π) (Icc (-1) 1)
state_after: no goals
Theorem: commProb_function
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: rw [commProb_pi, Finset.prod_const, Finset.card_univ]
state_before: M : Type u_1
inst✝² : Mul M
α : Type u_2
β : Type u_3
inst✝¹ : Fintype α
inst✝ : Mul β
⊢ commProb (α → β) = commProb β ^ card α
state_after: no goals
Theorem: RatFunc.num_mul_eq_mul_denom_iff
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rw [← (algebraMap_injective K).eq_iff, eq_div_iff (algebraMap_ne_zero hq)]
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ x.num * q = p * x.denom ↔ x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
state_after: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) (x.num * q) = (algebraMap K[X] (RatFunc K)) (p * x.denom) ↔
    x * (algebraMap K[X] (RatFunc K)) q = (algebraMap K[X] (RatFunc K)) p

tactic: conv_rhs => rw [← num_div_denom x]
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) (x.num * q) = (algebraMap K[X] (RatFunc K)) (p * x.denom) ↔
    x * (algebraMap K[X] (RatFunc K)) q = (algebraMap K[X] (RatFunc K)) p
state_after: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) (x.num * q) = (algebraMap K[X] (RatFunc K)) (p * x.denom) ↔
    (algebraMap K[X] (RatFunc K)) x.num / (algebraMap K[X] (RatFunc K)) x.denom * (algebraMap K[X] (RatFunc K)) q =
      (algebraMap K[X] (RatFunc K)) p

tactic: rw [RingHom.map_mul, RingHom.map_mul, div_eq_mul_inv, mul_assoc, mul_comm (Inv.inv _), ←
  mul_assoc, ← div_eq_mul_inv, div_eq_iff]
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) (x.num * q) = (algebraMap K[X] (RatFunc K)) (p * x.denom) ↔
    (algebraMap K[X] (RatFunc K)) x.num / (algebraMap K[X] (RatFunc K)) x.denom * (algebraMap K[X] (RatFunc K)) q =
      (algebraMap K[X] (RatFunc K)) p
state_after: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) x.denom ≠ 0

tactic: exact algebraMap_ne_zero (denom_ne_zero x)
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
p q : K[X]
hq : q ≠ 0
⊢ (algebraMap K[X] (RatFunc K)) x.denom ≠ 0
state_after: no goals
Theorem: ENNReal.ofReal_lt_natCast
File: Mathlib/Data/ENNReal/Real.lean

tactic: exact mod_cast ofReal_lt_ofReal_iff (Nat.cast_pos.2 hn.bot_lt)
state_before: a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ
n : ℕ
hn : n ≠ 0
⊢ ENNReal.ofReal p < ↑n ↔ p < ↑n
state_after: no goals
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inl_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.left = pullback.fst.unop
state_after: no goals
Theorem: pi_eq_sum_univ
File: Mathlib/Algebra/BigOperators/Pi.lean

tactic: ext
state_before: ι : Type u_1
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
R : Type u_2
inst✝ : Semiring R
x : ι → R
⊢ x = ∑ i : ι, x i • fun j => if i = j then 1 else 0
state_after: case h
ι : Type u_1
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
R : Type u_2
inst✝ : Semiring R
x : ι → R
x✝ : ι
⊢ x x✝ = (∑ i : ι, x i • fun j => if i = j then 1 else 0) x✝

tactic: simp
state_before: case h
ι : Type u_1
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
R : Type u_2
inst✝ : Semiring R
x : ι → R
x✝ : ι
⊢ x x✝ = (∑ i : ι, x i • fun j => if i = j then 1 else 0) x✝
state_after: no goals
Theorem: continuousWithinAt_compl_self
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [compl_eq_univ_diff, continuousWithinAt_diff_self, continuousWithinAt_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
a : α
⊢ ContinuousWithinAt f {a}ᶜ a ↔ ContinuousAt f a
state_after: no goals
Theorem: eqRec_heq_iff_heq
File: .lake/packages/batteries/Batteries/Logic.lean

tactic: subst e
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
a' : α
e : a = a'
β : Sort u_2
y : β
⊢ HEq (e ▸ x) y ↔ HEq x y
state_after: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq (⋯ ▸ x) y ↔ HEq x y

tactic: rfl
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq (⋯ ▸ x) y ↔ HEq x y
state_after: no goals
Theorem: MeasureTheory.withDensity_tsum
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

tactic: ext1 s hs
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
⊢ μ.withDensity (∑' (n : ℕ), f n) = sum fun n => μ.withDensity (f n)
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (∑' (n : ℕ), f n)) s = (sum fun n => μ.withDensity (f n)) s

tactic: simp_rw [sum_apply _ hs, withDensity_apply _ hs]
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (∑' (n : ℕ), f n)) s = (sum fun n => μ.withDensity (f n)) s
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, tsum (fun n => f n) a ∂μ = ∑' (i : ℕ), ∫⁻ (a : α) in s, f i a ∂μ

tactic: change ∫⁻ x in s, (∑' n, f n) x ∂μ = ∑' i : ℕ, ∫⁻ x, f i x ∂μ.restrict s
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, tsum (fun n => f n) a ∂μ = ∑' (i : ℕ), ∫⁻ (a : α) in s, f i a ∂μ
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, tsum (fun n => f n) x ∂μ = ∑' (i : ℕ), ∫⁻ (x : α) in s, f i x ∂μ

tactic: rw [← lintegral_tsum fun i => (h i).aemeasurable]
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, tsum (fun n => f n) x ∂μ = ∑' (i : ℕ), ∫⁻ (x : α) in s, f i x ∂μ
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, tsum (fun n => f n) x ∂μ = ∫⁻ (a : α) in s, ∑' (i : ℕ), f i a ∂μ

tactic: exact lintegral_congr fun x => tsum_apply (Pi.summable.2 fun _ => ENNReal.summable)
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : ℕ → α → ℝ≥0∞
h : ∀ (i : ℕ), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, tsum (fun n => f n) x ∂μ = ∫⁻ (a : α) in s, ∑' (i : ℕ), f i a ∂μ
state_after: no goals
Theorem: Nat.iInf_of_empty
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [iInf_of_isEmpty, sInf_empty]
state_before: ι : Sort u_1
inst✝ : IsEmpty ι
f : ι → ℕ
⊢ iInf f = 0
state_after: no goals
Theorem: List.mem_getLast?_cons
File: Mathlib/Data/List/Basic.lean

tactic: contradiction
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x y : α
x✝ : x ∈ [].getLast?
⊢ x ∈ [y].getLast?
state_after: no goals