tasksource/leandojo huggingface dataset:
Theorem: Real.one_lt_exp_iff
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← exp_zero, exp_lt_exp]
state_before: x✝ y x : ℝ
⊢ 1 < exp x ↔ 0 < x
Theorem: MeasureTheory.le_trim
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [Measure.trim]
state_before: α : Type u_1
β : Type ?u.3497107
γ : Type ?u.3497110
δ : Type ?u.3497113
ι : Type ?u.3497116
R : Type ?u.3497119
R' : Type ?u.3497122
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
⊢ ↑↑μ s ≤ ↑↑(trim μ hm) s

tactic: exact @le_toMeasure_apply _ m _ _ _
state_before: α : Type u_1
β : Type ?u.3497107
γ : Type ?u.3497110
δ : Type ?u.3497113
ι : Type ?u.3497116
R : Type ?u.3497119
R' : Type ?u.3497122
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
⊢ ↑↑μ s ≤ ↑↑(OuterMeasure.toMeasure ↑μ (_ : m ≤ OuterMeasure.caratheodory ↑μ)) s
Theorem: ProbabilityTheory.pred_true_of_condCount_eq_one
File: Mathlib/Probability/CondCount.lean

tactic: have hsf := finite_of_condCount_ne_zero (by rw [h]; exact one_ne_zero)
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
h : ↑↑(condCount s) t = 1
⊢ s ⊆ t

tactic: rw [condCount, cond_apply _ hsf.measurableSet, mul_comm] at h
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
h : ↑↑(condCount s) t = 1
hsf : Set.Finite s
⊢ s ⊆ t

tactic: replace h := ENNReal.eq_inv_of_mul_eq_one_left h
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
h : ↑↑Measure.count (s ∩ t) * (↑↑Measure.count s)⁻¹ = 1
hsf : Set.Finite s
⊢ s ⊆ t

tactic: rw [inv_inv, Measure.count_apply_finite _ hsf, Measure.count_apply_finite _ (hsf.inter_of_left _),
  Nat.cast_inj] at h
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hsf : Set.Finite s
h : ↑↑Measure.count (s ∩ t) = (↑↑Measure.count s)⁻¹⁻¹
⊢ s ⊆ t

tactic: suffices s ∩ t = s by exact this ▸ fun x hx => hx.2
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hsf : Set.Finite s
h : Finset.card (Set.Finite.toFinset (_ : Set.Finite (s ∩ t))) = Finset.card (Set.Finite.toFinset hsf)
⊢ s ⊆ t

tactic: rw [← @Set.Finite.toFinset_inj _ _ _ (hsf.inter_of_left _) hsf]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hsf : Set.Finite s
h : Finset.card (Set.Finite.toFinset (_ : Set.Finite (s ∩ t))) = Finset.card (Set.Finite.toFinset hsf)
⊢ s ∩ t = s

tactic: exact Finset.eq_of_subset_of_card_le (Set.Finite.toFinset_mono <| s.inter_subset_left t) h.ge
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hsf : Set.Finite s
h : Finset.card (Set.Finite.toFinset (_ : Set.Finite (s ∩ t))) = Finset.card (Set.Finite.toFinset hsf)
⊢ Set.Finite.toFinset (_ : Set.Finite (s ∩ t)) = Set.Finite.toFinset hsf

tactic: rw [h]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
h : ↑↑(condCount s) t = 1
⊢ ↑↑(condCount ?m.112707) ?m.112708 ≠ 0

tactic: exact one_ne_zero
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
h : ↑↑(condCount s) t = 1
⊢ 1 ≠ 0

tactic: exact this ▸ fun x hx => hx.2
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hsf : Set.Finite s
h : Finset.card (Set.Finite.toFinset (_ : Set.Finite (s ∩ t))) = Finset.card (Set.Finite.toFinset hsf)
this : s ∩ t = s
⊢ s ⊆ t
Theorem: AddHom.le_map_tsub
File: Mathlib/Algebra/Order/Sub/Basic.lean

tactic: rw [tsub_le_iff_right, ← f.map_add]
state_before: α : Type u_2
β : Type u_1
inst✝⁷ : Preorder α
inst✝⁶ : Add α
inst✝⁵ : Sub α
inst✝⁴ : OrderedSub α
a✝ b✝ c d : α
inst✝³ : Preorder β
inst✝² : Add β
inst✝¹ : Sub β
inst✝ : OrderedSub β
f : AddHom α β
hf : Monotone ↑f
a b : α
⊢ ↑f a - ↑f b ≤ ↑f (a - b)

tactic: exact hf le_tsub_add
state_before: α : Type u_2
β : Type u_1
inst✝⁷ : Preorder α
inst✝⁶ : Add α
inst✝⁵ : Sub α
inst✝⁴ : OrderedSub α
a✝ b✝ c d : α
inst✝³ : Preorder β
inst✝² : Add β
inst✝¹ : Sub β
inst✝ : OrderedSub β
f : AddHom α β
hf : Monotone ↑f
a b : α
⊢ ↑f a ≤ ↑f (a - b + b)
Theorem: Polynomial.roots_map_of_injective_of_card_eq_natDegree
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: apply Multiset.eq_of_le_of_card_le (map_roots_le_of_injective p hf)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ Multiset.map (↑f) (roots p) = roots (map f p)

tactic: simpa only [Multiset.card_map, hroots] using (card_roots' _).trans (natDegree_map_le f p)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ ↑Multiset.card (roots (map f p)) ≤ ↑Multiset.card (Multiset.map (↑f) (roots p))
Theorem: Set.Nonempty.zero_smul
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simpa [mem_smul] using ht
state_before: F : Type ?u.85988
α : Type u_2
β : Type u_1
γ : Type ?u.85997
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
s : Set α
t : Set β
ht : Set.Nonempty t
⊢ 0 ⊆ 0 • t
Theorem: MvPolynomial.coeff_X_mul'
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: refine' (coeff_monomial_mul' _ _ _ _).trans _
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ coeff m (X s * p) = if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0

tactic: simp_rw [Finsupp.single_le_iff, Finsupp.mem_support_iff, Nat.succ_le_iff, pos_iff_ne_zero,
  one_mul]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
p : MvPolynomial σ R
⊢ (if Finsupp.single s 1 ≤ m then 1 * coeff (m - Finsupp.single s 1) p else 0) =
    if s ∈ m.support then coeff (m - Finsupp.single s 1) p else 0
Theorem: IsLocalization.coeffIntegerNormalization_of_not_mem_support
File: Mathlib/RingTheory/Localization/Integral.lean

tactic: simp only [coeffIntegerNormalization, h, mem_support_iff, eq_self_iff_true, not_true, Ne.def,
  dif_neg, not_false_iff]
state_before: R : Type u_2
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_1
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.3630
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
p : S[X]
i : ℕ
h : coeff p i = 0
⊢ coeffIntegerNormalization M p i = 0
Theorem: Polynomial.derivative_X_pow
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: convert derivative_C_mul_X_pow (1 : R) n <;> simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Semiring R
n : ℕ
⊢ ↑derivative (X ^ n) = ↑C ↑n * X ^ (n - 1)
Theorem: RingHom.range_top_iff_surjective
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: rw [coe_range, coe_top]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Subring R
f : R →+* S
⊢ ↑(range f) = ↑⊤ ↔ Set.range ↑f = Set.univ
Theorem: Int.ModEq.cancel_right_div_gcd
File: Mathlib/Data/Int/ModEq.lean

tactic: letI d := gcd m c
state_before: m n a b c d : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
⊢ a ≡ b [ZMOD m / ↑(gcd m c)]

tactic: have hmd := gcd_dvd_left m c
state_before: m n a b c d✝ : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
d : ℕ := gcd m c
⊢ a ≡ b [ZMOD m / ↑(gcd m c)]

tactic: have hcd := gcd_dvd_right m c
state_before: m n a b c d✝ : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
d : ℕ := gcd m c
hmd : ↑(gcd m c) ∣ m
⊢ a ≡ b [ZMOD m / ↑(gcd m c)]

tactic: rw [modEq_iff_dvd] at h ⊢
state_before: m n a b c d✝ : ℤ
hm : 0 < m
h : a * c ≡ b * c [ZMOD m]
d : ℕ := gcd m c
hmd : ↑(gcd m c) ∣ m
hcd : ↑(gcd m c) ∣ c
⊢ a ≡ b [ZMOD m / ↑(gcd m c)]

tactic: refine Int.dvd_of_dvd_mul_right_of_gcd_one (?_ : m / d ∣ c / d * (b - a)) ?_
state_before: m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := gcd m c
hmd : ↑(gcd m c) ∣ m
hcd : ↑(gcd m c) ∣ c
⊢ m / ↑(gcd m c) ∣ b - a

tactic: rw [mul_comm, ← Int.mul_ediv_assoc (b - a) hcd, sub_mul]
state_before: case refine_1
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := gcd m c
hmd : ↑(gcd m c) ∣ m
hcd : ↑(gcd m c) ∣ c
⊢ m / ↑d ∣ c / ↑d * (b - a)

tactic: exact Int.ediv_dvd_ediv hmd h
state_before: case refine_1
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := gcd m c
hmd : ↑(gcd m c) ∣ m
hcd : ↑(gcd m c) ∣ c
⊢ m / ↑d ∣ (b * c - a * c) / ↑(gcd m c)

tactic: rw [gcd_div hmd hcd, natAbs_ofNat, Nat.div_self (gcd_pos_of_ne_zero_left c hm.ne')]
state_before: case refine_2
m n a b c d✝ : ℤ
hm : 0 < m
h : m ∣ b * c - a * c
d : ℕ := gcd m c
hmd : ↑(gcd m c) ∣ m
hcd : ↑(gcd m c) ∣ c
⊢ gcd (m / ↑(gcd m c)) (c / ↑d) = 1
Theorem: Rel.dom_inv
File: Mathlib/Data/Rel.lean

tactic: ext x
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1450
r : Rel α β
⊢ dom (inv r) = codom r

tactic: rfl
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.1450
r : Rel α β
x : β
⊢ x ∈ dom (inv r) ↔ x ∈ codom r
Theorem: CategoryTheory.Limits.Fork.app_one_eq_ι_comp_left
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [← s.app_zero_eq_ι, ← s.w left, parallelPair_map_left]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Fork f g
⊢ s.π.app one = ι s ≫ f
Theorem: LocalizedModule.r.isEquiv
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [one_smul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x✝ : M × { x // x ∈ S }
m : M
s : { x // x ∈ S }
⊢ 1 • (m, s).snd • (m, s).fst = 1 • (m, s).snd • (m, s).fst

tactic: use u1 * u2 * s2
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x✝⁴ x✝³ x✝² : M × { x // x ∈ S }
m1 : M
s1 : { x // x ∈ S }
m2 : M
s2 : { x // x ∈ S }
x✝¹ : r S M (m1, s1) (m2, s2)
m3 : M
s3 : { x // x ∈ S }
x✝ : r S M (m2, s2) (m3, s3)
u1 : { x // x ∈ S }
hu1 : u1 • (m2, s2).snd • (m1, s1).fst = u1 • (m1, s1).snd • (m2, s2).fst
u2 : { x // x ∈ S }
hu2 : u2 • (m3, s3).snd • (m2, s2).fst = u2 • (m2, s2).snd • (m3, s3).fst
⊢ r S M (m1, s1) (m3, s3)

tactic: simp only [← mul_smul, smul_assoc, mul_assoc, mul_comm, mul_left_comm] at hu1' hu2'⊢
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x✝⁴ x✝³ x✝² : M × { x // x ∈ S }
m1 : M
s1 : { x // x ∈ S }
m2 : M
s2 : { x // x ∈ S }
x✝¹ : r S M (m1, s1) (m2, s2)
m3 : M
s3 : { x // x ∈ S }
x✝ : r S M (m2, s2) (m3, s3)
u1 : { x // x ∈ S }
hu1 : u1 • (m2, s2).snd • (m1, s1).fst = u1 • (m1, s1).snd • (m2, s2).fst
u2 : { x // x ∈ S }
hu2 : u2 • (m3, s3).snd • (m2, s2).fst = u2 • (m2, s2).snd • (m3, s3).fst
hu1' :
  (fun x x_1 => x • x_1) (u2 * s3) (u1 • (m1, s1).snd • (m2, s2).fst) =
    (fun x x_1 => x • x_1) (u2 * s3) (u1 • (m2, s2).snd • (m1, s1).fst)
hu2' :
  (fun x x_1 => x • x_1) (u1 * s1) (u2 • (m2, s2).snd • (m3, s3).fst) =
    (fun x x_1 => x • x_1) (u1 * s1) (u2 • (m3, s3).snd • (m2, s2).fst)
⊢ (u1 * u2 * s2) • (m3, s3).snd • (m1, s1).fst = (u1 * u2 * s2) • (m1, s1).snd • (m3, s3).fst

tactic: rw [hu2', hu1']
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x✝⁴ x✝³ x✝² : M × { x // x ∈ S }
m1 : M
s1 : { x // x ∈ S }
m2 : M
s2 : { x // x ∈ S }
x✝¹ : r S M (m1, s1) (m2, s2)
m3 : M
s3 : { x // x ∈ S }
x✝ : r S M (m2, s2) (m3, s3)
u1 : { x // x ∈ S }
hu1 : u1 • (m2, s2).snd • (m1, s1).fst = u1 • (m1, s1).snd • (m2, s2).fst
u2 : { x // x ∈ S }
hu2 : u2 • (m3, s3).snd • (m2, s2).fst = u2 • (m2, s2).snd • (m3, s3).fst
hu1' : (s1 * (s3 * (u1 * u2))) • m2 = (s2 * (s3 * (u1 * u2))) • m1
hu2' : (s1 * (s2 * (u1 * u2))) • m3 = (s1 * (s3 * (u1 * u2))) • m2
⊢ (s2 * (s3 * (u1 * u2))) • m1 = (s1 * (s2 * (u1 * u2))) • m3
Theorem: LieModule.nilpotencyLength_eq_succ_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: let s := {k | lowerCentralSeries R L M k = ⊥}
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
⊢ nilpotencyLength R L M = k + 1 ↔ lowerCentralSeries R L M (k + 1) = ⊥ ∧ lowerCentralSeries R L M k ≠ ⊥

tactic: change sInf s = k + 1 ↔ k + 1 ∈ s ∧ k ∉ s
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
s : Set ℕ := {k | lowerCentralSeries R L M k = ⊥}
⊢ nilpotencyLength R L M = k + 1 ↔ lowerCentralSeries R L M (k + 1) = ⊥ ∧ lowerCentralSeries R L M k ≠ ⊥

tactic: have hs : ∀ k₁ k₂, k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s := by
  rintro k₁ k₂ h₁₂ (h₁ : lowerCentralSeries R L M k₁ = ⊥)
  exact eq_bot_iff.mpr (h₁ ▸ antitone_lowerCentralSeries R L M h₁₂)
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
s : Set ℕ := {k | lowerCentralSeries R L M k = ⊥}
⊢ sInf s = k + 1 ↔ k + 1 ∈ s ∧ ¬k ∈ s

tactic: exact Nat.sInf_upward_closed_eq_succ_iff hs k
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
s : Set ℕ := {k | lowerCentralSeries R L M k = ⊥}
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
⊢ sInf s = k + 1 ↔ k + 1 ∈ s ∧ ¬k ∈ s

tactic: rintro k₁ k₂ h₁₂ (h₁ : lowerCentralSeries R L M k₁ = ⊥)
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
s : Set ℕ := {k | lowerCentralSeries R L M k = ⊥}
⊢ ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s

tactic: exact eq_bot_iff.mpr (h₁ ▸ antitone_lowerCentralSeries R L M h₁₂)
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
k : ℕ
s : Set ℕ := {k | lowerCentralSeries R L M k = ⊥}
k₁ k₂ : ℕ
h₁₂ : k₁ ≤ k₂
h₁ : lowerCentralSeries R L M k₁ = ⊥
⊢ k₂ ∈ s
Theorem: Matrix.list_prod_inv_reverse
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [List.reverse_nil, List.map_nil, List.prod_nil, inv_one]
state_before: l : Type ?u.356623
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
⊢ (List.prod [])⁻¹ = List.prod (List.map Inv.inv (List.reverse []))

tactic: rw [List.reverse_cons', List.map_concat, List.prod_concat, List.prod_cons, Matrix.mul_eq_mul,
  Matrix.mul_eq_mul, mul_inv_rev, list_prod_inv_reverse Xs]
state_before: l : Type ?u.356623
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
Xs : List (Matrix n n α)
⊢ (List.prod (A :: Xs))⁻¹ = List.prod (List.map Inv.inv (List.reverse (A :: Xs)))
Theorem: Polynomial.degree_toSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp [degree]
state_before: R : Type u
S : Type ?u.91195
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
⊢ degree (toSubring p T hp) = degree p
Theorem: MvPolynomial.isHomogeneous_X
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: apply isHomogeneous_monomial
state_before: σ : Type u_1
τ : Type ?u.153374
R : Type u_2
S : Type ?u.153380
inst✝ : CommSemiring R
i : σ
⊢ IsHomogeneous (X i) 1

tactic: rw [Finsupp.support_single_ne_zero _ one_ne_zero, Finset.sum_singleton]
state_before: case hn
σ : Type u_1
τ : Type ?u.153374
R : Type u_2
S : Type ?u.153380
inst✝ : CommSemiring R
i : σ
⊢ ∑ i_1 in (Finsupp.single i 1).support, ↑(Finsupp.single i 1) i_1 = 1

tactic: exact Finsupp.single_eq_same
state_before: case hn
σ : Type u_1
τ : Type ?u.153374
R : Type u_2
S : Type ?u.153380
inst✝ : CommSemiring R
i : σ
⊢ ↑(Finsupp.single i 1) i = 1
Theorem: UniformInducing.mk'
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: simp [eq_comm, Filter.ext_iff, subset_def, h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : ∀ (s : Set (α × α)), s ∈ 𝓤 α ↔ ∃ t, t ∈ 𝓤 β ∧ ∀ (x y : α), (f x, f y) ∈ t → (x, y) ∈ s
⊢ comap (fun x => (f x.fst, f x.snd)) (𝓤 β) = 𝓤 α
Theorem: AffineMap.lineMap_eq_right_iff
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [← @lineMap_eq_lineMap_iff k V1, lineMap_apply_one]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type ?u.478404
P2 : Type ?u.478407
V3 : Type ?u.478410
P3 : Type ?u.478413
V4 : Type ?u.478416
P4 : Type ?u.478419
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V1
inst✝¹¹ : Module k V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : Module k V2
inst✝⁷ : AffineSpace V2 P2
inst✝⁶ : AddCommGroup V3
inst✝⁵ : Module k V3
inst✝⁴ : AffineSpace V3 P3
inst✝³ : AddCommGroup V4
inst✝² : Module k V4
inst✝¹ : AffineSpace V4 P4
inst✝ : NoZeroSMulDivisors k V1
p₀ p₁ : P1
c : k
⊢ ↑(lineMap p₀ p₁) c = p₁ ↔ p₀ = p₁ ∨ c = 1
Theorem: CategoryTheory.Limits.IsZero.of_mono_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Mono 0
⊢ 𝟙 X ≫ 0 = 0 ≫ 0
Theorem: MeasureTheory.measurePreserving_div_right
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: simp_rw [div_eq_mul_inv, measurePreserving_mul_right μ g⁻¹]
state_before: 𝕜 : Type ?u.367252
G : Type u_1
H : Type ?u.367258
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
g : G
⊢ MeasurePreserving fun x => x / g
Theorem: CategoryTheory.unop_inv
File: Mathlib/CategoryTheory/Opposites.lean

tactic: aesop_cat_nonterminal
state_before: C : Type u₁
inst✝¹ : Category C
X Y : Cᵒᵖ
f : X ⟶ Y
inst✝ : IsIso f
⊢ (inv f).unop = inv f.unop

tactic: rw [← unop_comp, IsIso.inv_hom_id, unop_id]
state_before: case hom_inv_id
C : Type u₁
inst : Category C
X Y : Cᵒᵖ
f : X ⟶ Y
inst_1 : IsIso f
⊢ f.unop ≫ (inv f).unop = 𝟙 Y.unop
Theorem: Finset.mem_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_def, biUnion_val, mem_dedup, mem_bind, exists_prop]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.498019
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
b : β
⊢ b ∈ Finset.biUnion s t ↔ ∃ a, a ∈ s ∧ b ∈ t a
Theorem: MeasureTheory.weightedSMul_zero_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: ext1
state_before: α : Type u_1
E : Type ?u.11618
F : Type u_2
𝕜 : Type ?u.11624
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
⊢ weightedSMul 0 = 0

tactic: simp [weightedSMul]
state_before: case h
α : Type u_1
E : Type ?u.11618
F : Type u_2
𝕜 : Type ?u.11624
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
x✝ : Set α
⊢ weightedSMul 0 x✝ = OfNat.ofNat 0 x✝
Theorem: IsRightRegular.ne_zero
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rintro rfl
state_before: R : Type u_1
inst✝¹ : MulZeroClass R
a b : R
inst✝ : Nontrivial R
ra : IsRightRegular a
⊢ a ≠ 0

tactic: rcases exists_pair_ne R with ⟨x, y, xy⟩
state_before: R : Type u_1
inst✝¹ : MulZeroClass R
b : R
inst✝ : Nontrivial R
ra : IsRightRegular 0
⊢ False

tactic: refine' xy (ra (_ : x * 0 = y * 0))
state_before: case intro.intro
R : Type u_1
inst✝¹ : MulZeroClass R
b : R
inst✝ : Nontrivial R
ra : IsRightRegular 0
x y : R
xy : x ≠ y
⊢ False

tactic: rw [mul_zero, mul_zero]
state_before: case intro.intro
R : Type u_1
inst✝¹ : MulZeroClass R
b : R
inst✝ : Nontrivial R
ra : IsRightRegular 0
x y : R
xy : x ≠ y
⊢ x * 0 = y * 0
Theorem: HasDerivWithinAt.complexToReal_fderiv
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [Complex.restrictScalars_one_smulRight] using h.hasFDerivWithinAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type ?u.137741
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
s : Set ℂ
f' x : ℂ
h : HasDerivWithinAt f f' s x
⊢ HasFDerivWithinAt f (f' • 1) s x
Theorem: homology.map_comp
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type ?u.138713
V : Type u
inst✝¹⁹ : Category V
inst✝¹⁸ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹⁷ : HasImage f
g : B ⟶ C
inst✝¹⁶ : HasKernel g
w : f ≫ g = 0
A' B' C' : V
f' : A' ⟶ B'
inst✝¹⁵ : HasImage f'
g' : B' ⟶ C'
inst✝¹⁴ : HasKernel g'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
inst✝¹³ : HasImageMap α
β : Arrow.mk g ⟶ Arrow.mk g'
A₁ B₁ C₁ : V
f₁ : A₁ ⟶ B₁
inst✝¹² : HasImage f₁
g₁ : B₁ ⟶ C₁
inst✝¹¹ : HasKernel g₁
w₁ : f₁ ≫ g₁ = 0
A₂ B₂ C₂ : V
f₂ : A₂ ⟶ B₂
inst✝¹⁰ : HasImage f₂
g₂ : B₂ ⟶ C₂
inst✝⁹ : HasKernel g₂
w₂ : f₂ ≫ g₂ = 0
A₃ B₃ C₃ : V
f₃ : A₃ ⟶ B₃
inst✝⁸ : HasImage f₃
g₃ : B₃ ⟶ C₃
inst✝⁷ : HasKernel g₃
w₃ : f₃ ≫ g₃ = 0
α₁ : Arrow.mk f₁ ⟶ Arrow.mk f₂
inst✝⁶ : HasImageMap α₁
β₁ : Arrow.mk g₁ ⟶ Arrow.mk g₂
α₂ : Arrow.mk f₂ ⟶ Arrow.mk f₃
inst✝⁵ : HasImageMap α₂
β₂ : Arrow.mk g₂ ⟶ Arrow.mk g₃
inst✝⁴ : HasCokernel (imageToKernel f g w)
inst✝³ : HasCokernel (imageToKernel f' g' w')
inst✝² : HasCokernel (imageToKernel f₁ g₁ w₁)
inst✝¹ : HasCokernel (imageToKernel f₂ g₂ w₂)
inst✝ : HasCokernel (imageToKernel f₃ g₃ w₃)
p₁ : α₁.right = β₁.left
p₂ : α₂.right = β₂.left
⊢ map w₁ w₂ α₁ β₁ p₁ ≫ map w₂ w₃ α₂ β₂ p₂ = map w₁ w₃ (α₁ ≫ α₂) (β₁ ≫ β₂) (_ : (α₁ ≫ α₂).right = (β₁ ≫ β₂).left)

tactic: simp only [kernelSubobjectMap_comp, homology.π_map_assoc, homology.π_map, Category.assoc]
state_before: case p
ι : Type ?u.138713
V : Type u
inst✝¹⁹ : Category V
inst✝¹⁸ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹⁷ : HasImage f
g : B ⟶ C
inst✝¹⁶ : HasKernel g
w : f ≫ g = 0
A' B' C' : V
f' : A' ⟶ B'
inst✝¹⁵ : HasImage f'
g' : B' ⟶ C'
inst✝¹⁴ : HasKernel g'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
inst✝¹³ : HasImageMap α
β : Arrow.mk g ⟶ Arrow.mk g'
A₁ B₁ C₁ : V
f₁ : A₁ ⟶ B₁
inst✝¹² : HasImage f₁
g₁ : B₁ ⟶ C₁
inst✝¹¹ : HasKernel g₁
w₁ : f₁ ≫ g₁ = 0
A₂ B₂ C₂ : V
f₂ : A₂ ⟶ B₂
inst✝¹⁰ : HasImage f₂
g₂ : B₂ ⟶ C₂
inst✝⁹ : HasKernel g₂
w₂ : f₂ ≫ g₂ = 0
A₃ B₃ C₃ : V
f₃ : A₃ ⟶ B₃
inst✝⁸ : HasImage f₃
g₃ : B₃ ⟶ C₃
inst✝⁷ : HasKernel g₃
w₃ : f₃ ≫ g₃ = 0
α₁ : Arrow.mk f₁ ⟶ Arrow.mk f₂
inst✝⁶ : HasImageMap α₁
β₁ : Arrow.mk g₁ ⟶ Arrow.mk g₂
α₂ : Arrow.mk f₂ ⟶ Arrow.mk f₃
inst✝⁵ : HasImageMap α₂
β₂ : Arrow.mk g₂ ⟶ Arrow.mk g₃
inst✝⁴ : HasCokernel (imageToKernel f g w)
inst✝³ : HasCokernel (imageToKernel f' g' w')
inst✝² : HasCokernel (imageToKernel f₁ g₁ w₁)
inst✝¹ : HasCokernel (imageToKernel f₂ g₂ w₂)
inst✝ : HasCokernel (imageToKernel f₃ g₃ w₃)
p₁ : α₁.right = β₁.left
p₂ : α₂.right = β₂.left
⊢ π f₁ g₁ w₁ ≫ map w₁ w₂ α₁ β₁ p₁ ≫ map w₂ w₃ α₂ β₂ p₂ =
    π f₁ g₁ w₁ ≫ map w₁ w₃ (α₁ ≫ α₂) (β₁ ≫ β₂) (_ : (α₁ ≫ α₂).right = (β₁ ≫ β₂).left)
Theorem: Real.Angle.neg_ne_self_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_or, ← neg_eq_self_iff.not]
state_before: θ : Angle
⊢ -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ ↑π
Theorem: quotientMap_iff_closed
File: Mathlib/Topology/Maps.lean

tactic: simp only [isOpen_compl_iff, preimage_compl]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.136882
δ : Type ?u.136885
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
⊢ (∀ (x : Set β), IsOpen (xᶜ) ↔ IsOpen (f ⁻¹' xᶜ)) ↔ ∀ (s : Set β), IsClosed s ↔ IsClosed (f ⁻¹' s)