1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MvPolynomial.algebraTensorAlgEquiv_tmul
File: Mathlib/RingTheory/TensorProduct/MvPolynomial.lean

tactic: simp [algebraTensorAlgEquiv]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
a : A
p : MvPolynomial σ R
⊢ (algebraTensorAlgEquiv R A) (a ⊗ₜ[R] p) = a • (map (algebraMap R A)) p
state_after: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
a : A
p : MvPolynomial σ R
⊢ (Algebra.ofId A (MvPolynomial σ A)) a * eval₂ (C.comp ↑(Algebra.ofId R A)) X p = a • (map (algebraMap R A)) p

tactic: rw [Algebra.smul_def]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
a : A
p : MvPolynomial σ R
⊢ (Algebra.ofId A (MvPolynomial σ A)) a * eval₂ (C.comp ↑(Algebra.ofId R A)) X p = a • (map (algebraMap R A)) p
state_after: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
a : A
p : MvPolynomial σ R
⊢ (Algebra.ofId A (MvPolynomial σ A)) a * eval₂ (C.comp ↑(Algebra.ofId R A)) X p =
    (algebraMap A (MvPolynomial σ A)) a * (map (algebraMap R A)) p

tactic: rfl
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
a : A
p : MvPolynomial σ R
⊢ (Algebra.ofId A (MvPolynomial σ A)) a * eval₂ (C.comp ↑(Algebra.ofId R A)) X p =
    (algebraMap A (MvPolynomial σ A)) a * (map (algebraMap R A)) p
state_after: no goals
Theorem: HahnSeries.sub_coeff'
File: Mathlib/RingTheory/HahnSeries/Addition.lean

tactic: ext
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
⊢ (x - y).coeff = x.coeff - y.coeff
state_after: case h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
x✝ : Γ
⊢ (x - y).coeff x✝ = (x.coeff - y.coeff) x✝

tactic: simp [sub_eq_add_neg]
state_before: case h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
x✝ : Γ
⊢ (x - y).coeff x✝ = (x.coeff - y.coeff) x✝
state_after: no goals
Theorem: Nat.chineseRemainder'_lt_lcm
File: Mathlib/Data/Nat/ModEq.lean

tactic: dsimp only [chineseRemainder']
state_before: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ↑(chineseRemainder' h) < n.lcm m
state_after: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ↑(if hn : n = 0 then ⟨a, ⋯⟩
      else
        if hm : m = 0 then ⟨b, ⋯⟩
        else ⟨((↑n * (n.xgcd m).1 * ↑b + ↑m * (n.xgcd m).2 * ↑a) / ↑(n.gcd m) % ↑(n.lcm m)).toNat, ⋯⟩) <
    n.lcm m

tactic: rw [dif_neg hn, dif_neg hm, Subtype.coe_mk, xgcd_val, ← Int.toNat_natCast (lcm n m)]
state_before: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ↑(if hn : n = 0 then ⟨a, ⋯⟩
      else
        if hm : m = 0 then ⟨b, ⋯⟩
        else ⟨((↑n * (n.xgcd m).1 * ↑b + ↑m * (n.xgcd m).2 * ↑a) / ↑(n.gcd m) % ↑(n.lcm m)).toNat, ⋯⟩) <
    n.lcm m
state_after: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ((↑n * (n.gcdA m, n.gcdB m).1 * ↑b + ↑m * (n.gcdA m, n.gcdB m).2 * ↑a) / ↑(n.gcd m) % ↑(↑(n.lcm m)).toNat).toNat <
    (↑(n.lcm m)).toNat

tactic: have lcm_pos := Int.natCast_pos.mpr (Nat.pos_of_ne_zero (lcm_ne_zero hn hm))
state_before: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ((↑n * (n.gcdA m, n.gcdB m).1 * ↑b + ↑m * (n.gcdA m, n.gcdB m).2 * ↑a) / ↑(n.gcd m) % ↑(↑(n.lcm m)).toNat).toNat <
    (↑(n.lcm m)).toNat
state_after: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
lcm_pos : 0 < ↑(n.lcm m)
⊢ ((↑n * (n.gcdA m, n.gcdB m).1 * ↑b + ↑m * (n.gcdA m, n.gcdB m).2 * ↑a) / ↑(n.gcd m) % ↑(↑(n.lcm m)).toNat).toNat <
    (↑(n.lcm m)).toNat

tactic: exact (Int.toNat_lt_toNat lcm_pos).mpr (Int.emod_lt_of_pos _ lcm_pos)
state_before: m n a b c d : ℕ
h : a ≡ b [MOD n.gcd m]
hn : n ≠ 0
hm : m ≠ 0
lcm_pos : 0 < ↑(n.lcm m)
⊢ ((↑n * (n.gcdA m, n.gcdB m).1 * ↑b + ↑m * (n.gcdA m, n.gcdB m).2 * ↑a) / ↑(n.gcd m) % ↑(↑(n.lcm m)).toNat).toNat <
    (↑(n.lcm m)).toNat
state_after: no goals
Theorem: lipschitzOn_univ
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: simp [LipschitzOnWith, LipschitzWith]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
f : α → β
⊢ LipschitzOnWith K f univ ↔ LipschitzWith K f
state_after: no goals
Theorem: Finset.not_disjoint_iff_nonempty_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [Finset.Nonempty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ (∃ a ∈ s, a ∈ t) ↔ (s ∩ t).Nonempty
state_after: no goals
Theorem: OreLocalization.smul_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: induction' x with r s
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
x : OreLocalization S R
⊢ x • 0 = 0
state_after: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r : R
s : ↥S
⊢ (r /ₒ s) • 0 = 0

tactic: rw [OreLocalization.zero_def, smul_div_one, smul_zero, zero_oreDiv, zero_oreDiv]
state_before: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r : R
s : ↥S
⊢ (r /ₒ s) • 0 = 0
state_after: no goals
Theorem: Multiset.card_toEnumFinset
File: Mathlib/Data/Multiset/Fintype.lean

tactic: rw [Finset.card, ← Multiset.card_map Prod.fst m.toEnumFinset.val]
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ m.toEnumFinset.card = card m
state_after: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ card (map Prod.fst m.toEnumFinset.val) = card m

tactic: congr
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ card (map Prod.fst m.toEnumFinset.val) = card m
state_after: case h.e_6.h
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ map Prod.fst m.toEnumFinset.val = m

tactic: exact m.map_toEnumFinset_fst
state_before: case h.e_6.h
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ map Prod.fst m.toEnumFinset.val = m
state_after: no goals
Theorem: LiouvilleWith.mul_nat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rw [← Rat.cast_natCast, mul_rat_iff (Nat.cast_ne_zero.2 hn)]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
hn : n ≠ 0
⊢ LiouvilleWith p (x * ↑n) ↔ LiouvilleWith p x
state_after: no goals
Theorem: Inducing.isCompact_preimage_iff
File: Mathlib/Topology/Compactness/Compact.lean

tactic: rw [hf.isCompact_iff, image_preimage_eq_of_subset Kf]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
K : Set Y
Kf : K ⊆ range f
⊢ IsCompact (f ⁻¹' K) ↔ IsCompact K
state_after: no goals
Theorem: abs_sub_le
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [sub_add_sub_cancel]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ d a b c : α
⊢ |a - c| = |a - b + (b - c)|
state_after: no goals
Theorem: SlimCheck.InjectiveFunction.List.applyId_cons
File: Mathlib/Testing/SlimCheck/Functions.lean

tactic: simp only [List.applyId, List.dlookup, eq_rec_constant, Prod.toSigma, List.map]
state_before: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs : List (α × α)
x y z : α
⊢ applyId ((y, z) :: xs) x = if y = x then z else applyId xs x
state_after: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs : List (α × α)
x y z : α
⊢ (if h : y = x then some z else dlookup x (map Prod.toSigma xs)).getD x =
    if y = x then z else (dlookup x (map Prod.toSigma xs)).getD x

tactic: split_ifs <;> rfl
state_before: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs : List (α × α)
x y z : α
⊢ (if h : y = x then some z else dlookup x (map Prod.toSigma xs)).getD x =
    if y = x then z else (dlookup x (map Prod.toSigma xs)).getD x
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.tendsto_iff_forall_lintegral_tendsto
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [tendsto_iff_forall_toWeakDualBCNN_tendsto]
state_before: Ω : Type u_1
inst✝⁶ : MeasurableSpace Ω
R : Type u_2
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_3
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (x : Ω), ↑(f x) ∂↑(μs i)) F (𝓝 (∫⁻ (x : Ω), ↑(f x) ∂↑μ))
state_after: Ω : Type u_1
inst✝⁶ : MeasurableSpace Ω
R : Type u_2
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_3
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => (μs i).toWeakDualBCNN f) F (𝓝 (μ.toWeakDualBCNN f))) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (x : Ω), ↑(f x) ∂↑(μs i)) F (𝓝 (∫⁻ (x : Ω), ↑(f x) ∂↑μ))

tactic: simp_rw [toWeakDualBCNN_apply _ _, ← testAgainstNN_coe_eq, ENNReal.tendsto_coe,
  ENNReal.toNNReal_coe]
state_before: Ω : Type u_1
inst✝⁶ : MeasurableSpace Ω
R : Type u_2
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_3
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => (μs i).toWeakDualBCNN f) F (𝓝 (μ.toWeakDualBCNN f))) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (x : Ω), ↑(f x) ∂↑(μs i)) F (𝓝 (∫⁻ (x : Ω), ↑(f x) ∂↑μ))
state_after: no goals
Theorem: MeasureTheory.L1.setToL1_simpleFunc_indicatorConst
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [setToL1_eq_setToL1SCLM]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
hT : DominatedFinMeasAdditive μ T C
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
x : E
⊢ (setToL1 hT) ↑(indicatorConst 1 hs ⋯ x) = (T s) x
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
hT : DominatedFinMeasAdditive μ T C
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
x : E
⊢ (setToL1SCLM α E μ hT) (indicatorConst 1 hs ⋯ x) = (T s) x

tactic: exact setToL1S_indicatorConst (fun s => hT.eq_zero_of_measure_zero) hT.1 hs hμs x
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
hT : DominatedFinMeasAdditive μ T C
s : Set α
hs : MeasurableSet s
hμs : μ s < ⊤
x : E
⊢ (setToL1SCLM α E μ hT) (indicatorConst 1 hs ⋯ x) = (T s) x
state_after: no goals
Theorem: WeierstrassCurve.φ_two
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: erw [φ, ψ_two, ψ_three, ψ_one, mul_one]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.φ 2 = C X * W.ψ₂ ^ 2 - C W.Ψ₃
state_after: no goals
Theorem: CompleteSpace.fst_of_prod
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simpa only [map_fst_prod, nhds_prod_eq] using map_mono (m := Prod.fst) hab
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompleteSpace (α × β)
h : Nonempty β
f✝ : Filter α
hf : Cauchy f✝
y : β
a : α
b : β
hab : f✝ ×ˢ pure y ≤ 𝓝 (a, b)
⊢ f✝ ≤ 𝓝 a
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.HeapNode.WF.realSize_eq
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Lemmas.lean

tactic: rw [realSize, realSize_eq c, Nat.pow_succ, Nat.mul_succ]
state_before: α : Type u_1
le : α → α → Bool
a a✝² : α
a✝¹ a✝ : HeapNode α
w✝ : Nat
left✝ : ∀ [inst : TotalBLE le], le a a✝² = true
c : WF le a✝² a✝¹ w✝
s : WF le a a✝ w✝
⊢ (node a✝² a✝¹ a✝).realSize + 1 = 2 ^ (w✝ + 1)
state_after: α : Type u_1
le : α → α → Bool
a a✝² : α
a✝¹ a✝ : HeapNode α
w✝ : Nat
left✝ : ∀ [inst : TotalBLE le], le a a✝² = true
c : WF le a✝² a✝¹ w✝
s : WF le a a✝ w✝
⊢ 2 ^ w✝ + a✝.realSize + 1 = 2 ^ w✝ * 1 + 2 ^ w✝

tactic: simp [Nat.add_assoc, realSize_eq s]
state_before: α : Type u_1
le : α → α → Bool
a a✝² : α
a✝¹ a✝ : HeapNode α
w✝ : Nat
left✝ : ∀ [inst : TotalBLE le], le a a✝² = true
c : WF le a✝² a✝¹ w✝
s : WF le a a✝ w✝
⊢ 2 ^ w✝ + a✝.realSize + 1 = 2 ^ w✝ * 1 + 2 ^ w✝
state_after: no goals
Theorem: conjugate_pos
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa only [mul_zero, zero_mul] using conjugate_lt_conjugate ha hc
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a : R
ha : 0 < a
c : R
hc : IsRegular c
⊢ 0 < star c * a * c
state_after: no goals
Theorem: Class.congToClass_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext z
state_before: ⊢ congToClass ∅ = ∅
state_after: case a
z : ZFSet
⊢ congToClass ∅ z ↔ ∅ z

tactic: simp only [congToClass, not_empty_hom, iff_false_iff]
state_before: case a
z : ZFSet
⊢ congToClass ∅ z ↔ ∅ z
state_after: case a
z : ZFSet
⊢ ¬{y | ↑y ∈ ∅} z

tactic: exact Set.not_mem_empty z
state_before: case a
z : ZFSet
⊢ ¬{y | ↑y ∈ ∅} z
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
⊢ (λ_ (X ⊗ Y)).hom = (α_ (𝟙_ C) X Y).inv ≫ (λ_ X).hom ▷ Y
state_after: no goals
Theorem: Multiset.mem_sym2_iff
File: Mathlib/Data/Multiset/Sym.lean

tactic: simp [List.mem_sym2_iff]
state_before: α : Type u_1
m : Multiset α
z : Sym2 α
xs : List α
⊢ z ∈ Multiset.sym2 ⟦xs⟧ ↔ ∀ y ∈ z, y ∈ ⟦xs⟧
state_after: no goals
Theorem: CommSemiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro rfl
state_before: R : Type u
inst₁ inst₂ : CommSemiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : CommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul

tactic: constructor <;> rfl
state_before: R : Type u
inst₁ : CommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
Theorem: gauge_neg_set_neg
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: simp_rw [gauge_def', smul_neg, neg_mem_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
⊢ gauge (-s) (-x) = gauge s x
state_after: no goals
Theorem: Matrix.eta_fin_two
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext i j
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
⊢ A = of ![![A 0 0, A 0 1], ![A 1 0, A 1 1]]
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A i j = of ![![A 0 0, A 0 1], ![A 1 0, A 1 1]] i j

tactic: fin_cases i <;> fin_cases j <;> rfl
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A i j = of ![![A 0 0, A 0 1], ![A 1 0, A 1 1]] i j
state_after: no goals
Theorem: Vector.toList_drop
File: Mathlib/Data/Vector/Defs.lean

tactic: cases v
state_before: α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
v : Vector α m
⊢ (drop n v).toList = List.drop n v.toList
state_after: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝ : List α
property✝ : val✝.length = m
⊢ (drop n ⟨val✝, property✝⟩).toList = List.drop n (toList ⟨val✝, property✝⟩)

tactic: rfl
state_before: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝ : List α
property✝ : val✝.length = m
⊢ (drop n ⟨val✝, property✝⟩).toList = List.drop n (toList ⟨val✝, property✝⟩)
state_after: no goals
Theorem: Complex.hasStrictDerivAt_log
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

tactic: simpa [exp_log h0] using hasStrictDerivAt_exp (log x)
state_before: x : ℂ
h : x ∈ slitPlane
h0 : x ≠ 0
⊢ HasStrictDerivAt (↑expPartialHomeomorph) x (↑expPartialHomeomorph.symm x)
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.exact_C₃_up
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: rw [← comp_τ₃, S.w₀₂, zero_τ₃]
state_before: C : Type u_1
inst✝¹ : Category.{?u.28206, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.v₀₁.τ₃ ≫ S.v₁₂.τ₃ = 0
state_after: no goals
Theorem: ENNReal.dichotomy
File: Mathlib/Data/ENNReal/Real.lean

tactic: simpa using ENNReal.trichotomy₂ (Fact.out : 1 ≤ p)
state_before: a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ≥0∞
inst✝ : Fact (1 ≤ p)
⊢ p = ⊤ ∨ 0 < p.toReal ∧ 1 ≤ p.toReal
state_after: no goals
Theorem: UpperHalfPlane.isometry_pos_mul
File: Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean

tactic: refine Isometry.of_dist_eq fun y₁ y₂ => ?_
state_before: z w : ℍ
r R : ℝ
a : { x // 0 < x }
⊢ Isometry fun x => a • x
state_after: z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ dist (a • y₁) (a • y₂) = dist y₁ y₂

tactic: simp only [dist_eq, coe_pos_real_smul, pos_real_im]
state_before: z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ dist (a • y₁) (a • y₂) = dist y₁ y₂
state_after: z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ 2 * arsinh (dist (↑a • ↑y₁) (↑a • ↑y₂) / (2 * √(↑a * y₁.im * (↑a * y₂.im)))) =
    2 * arsinh (dist ↑y₁ ↑y₂ / (2 * √(y₁.im * y₂.im)))

tactic: congr 2
state_before: z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ 2 * arsinh (dist (↑a • ↑y₁) (↑a • ↑y₂) / (2 * √(↑a * y₁.im * (↑a * y₂.im)))) =
    2 * arsinh (dist ↑y₁ ↑y₂ / (2 * √(y₁.im * y₂.im)))
state_after: case e_a.e_x
z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ dist (↑a • ↑y₁) (↑a • ↑y₂) / (2 * √(↑a * y₁.im * (↑a * y₂.im))) = dist ↑y₁ ↑y₂ / (2 * √(y₁.im * y₂.im))

tactic: rw [dist_smul₀, mul_mul_mul_comm, Real.sqrt_mul (mul_self_nonneg _), Real.sqrt_mul_self_eq_abs,
  Real.norm_eq_abs, mul_left_comm]
state_before: case e_a.e_x
z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ dist (↑a • ↑y₁) (↑a • ↑y₂) / (2 * √(↑a * y₁.im * (↑a * y₂.im))) = dist ↑y₁ ↑y₂ / (2 * √(y₁.im * y₂.im))
state_after: case e_a.e_x
z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ |↑a| * dist ↑y₁ ↑y₂ / (|↑a| * (2 * √(y₁.im * y₂.im))) = dist ↑y₁ ↑y₂ / (2 * √(y₁.im * y₂.im))

tactic: exact mul_div_mul_left _ _ (mt _root_.abs_eq_zero.1 a.2.ne')
state_before: case e_a.e_x
z w : ℍ
r R : ℝ
a : { x // 0 < x }
y₁ y₂ : ℍ
⊢ |↑a| * dist ↑y₁ ↑y₂ / (|↑a| * (2 * √(y₁.im * y₂.im))) = dist ↑y₁ ↑y₂ / (2 * √(y₁.im * y₂.im))
state_after: no goals
Theorem: ZMod.pow_card_sub_one
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: split_ifs with ha
state_before: K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
⊢ a ^ (p - 1) = if a ≠ 0 then 1 else 0
state_after: case pos
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
⊢ a ^ (p - 1) = 1

case neg
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : ¬a ≠ 0
⊢ a ^ (p - 1) = 0

tactic: exact pow_card_sub_one_eq_one ha
state_before: case pos
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
⊢ a ^ (p - 1) = 1
state_after: no goals

tactic: simp [of_not_not ha, (Fact.out : p.Prime).one_lt, tsub_eq_zero_iff_le]
state_before: case neg
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : ¬a ≠ 0
⊢ a ^ (p - 1) = 0
state_after: no goals
Theorem: Set.mulIndicator_self_mul_compl_apply
File: Mathlib/Algebra/Group/Indicator.lean

tactic: simp [ha]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
ha : a ∈ s
⊢ s.mulIndicator f a * sᶜ.mulIndicator f a = f a
state_after: no goals

tactic: simp [ha]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
ha : a ∉ s
⊢ s.mulIndicator f a * sᶜ.mulIndicator f a = f a
state_after: no goals