1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: vadd_eq_vadd_iff_sub_eq_vsub
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [vadd_eq_vadd_iff_neg_add_eq_vsub, neg_add_eq_sub]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
v₁ v₂ : G
p₁ p₂ : P
⊢ v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ v₂ - v₁ = p₁ -ᵥ p₂
state_after: no goals
Theorem: ProbabilityTheory.IndepFun_iff
File: Mathlib/Probability/Independence/Basic.lean

tactic: rw [IndepFun_iff_Indep, Indep_iff]
state_before: Ω : Type u_1
ι : Type u_2
β✝ : Type u_3
γ✝ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
β : Type u_6
γ : Type u_7
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : Ω → β
g : Ω → γ
μ : Measure Ω
⊢ IndepFun f g μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
state_after: no goals
Theorem: Ideal.Quotient.mk_singleton_self
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: rw [eq_zero_iff_dvd]
state_before: R : Type u
inst✝ : CommRing R
I : Ideal R
a b : R
S : Type v
x✝ y x : R
⊢ (mk (span {x})) x = 0
state_after: no goals
Theorem: IsPrimitiveRoot.norm_eq_one_of_linearly_ordered
File: Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean

tactic: have hz := congr_arg (norm K) ((IsPrimitiveRoot.iff_def _ n).1 hζ).1
state_before: p n : ℕ+
A : Type w
B : Type z
K✝ : Type u
L : Type v
C : Type w
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra A B
inst✝⁵ : IsCyclotomicExtension {n} A B
inst✝⁴ : CommRing L
ζ : L
hζ : IsPrimitiveRoot ζ ↑n
inst✝³ : Field K✝
inst✝² : Algebra K✝ L
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : Algebra K L
hodd : Odd ↑n
⊢ (Algebra.norm K) ζ = 1
state_after: p n : ℕ+
A : Type w
B : Type z
K✝ : Type u
L : Type v
C : Type w
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra A B
inst✝⁵ : IsCyclotomicExtension {n} A B
inst✝⁴ : CommRing L
ζ : L
hζ : IsPrimitiveRoot ζ ↑n
inst✝³ : Field K✝
inst✝² : Algebra K✝ L
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : Algebra K L
hodd : Odd ↑n
hz : (Algebra.norm K) (ζ ^ ↑n) = (Algebra.norm K) 1
⊢ (Algebra.norm K) ζ = 1

tactic: rw [← (algebraMap K L).map_one, Algebra.norm_algebraMap, one_pow, map_pow, ← one_pow ↑n] at hz
state_before: p n : ℕ+
A : Type w
B : Type z
K✝ : Type u
L : Type v
C : Type w
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra A B
inst✝⁵ : IsCyclotomicExtension {n} A B
inst✝⁴ : CommRing L
ζ : L
hζ : IsPrimitiveRoot ζ ↑n
inst✝³ : Field K✝
inst✝² : Algebra K✝ L
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : Algebra K L
hodd : Odd ↑n
hz : (Algebra.norm K) (ζ ^ ↑n) = (Algebra.norm K) 1
⊢ (Algebra.norm K) ζ = 1
state_after: p n : ℕ+
A : Type w
B : Type z
K✝ : Type u
L : Type v
C : Type w
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra A B
inst✝⁵ : IsCyclotomicExtension {n} A B
inst✝⁴ : CommRing L
ζ : L
hζ : IsPrimitiveRoot ζ ↑n
inst✝³ : Field K✝
inst✝² : Algebra K✝ L
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : Algebra K L
hodd : Odd ↑n
hz : (Algebra.norm K) ζ ^ ↑n = 1 ^ ↑n
⊢ (Algebra.norm K) ζ = 1

tactic: exact StrictMono.injective hodd.strictMono_pow hz
state_before: p n : ℕ+
A : Type w
B : Type z
K✝ : Type u
L : Type v
C : Type w
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra A B
inst✝⁵ : IsCyclotomicExtension {n} A B
inst✝⁴ : CommRing L
ζ : L
hζ : IsPrimitiveRoot ζ ↑n
inst✝³ : Field K✝
inst✝² : Algebra K✝ L
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : Algebra K L
hodd : Odd ↑n
hz : (Algebra.norm K) ζ ^ ↑n = 1 ^ ↑n
⊢ (Algebra.norm K) ζ = 1
state_after: no goals
Theorem: PowerSeries.order_eq_nat
File: Mathlib/RingTheory/PowerSeries/Order.lean

tactic: rcases eq_or_ne φ 0 with (rfl | hφ)
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
⊢ φ.order = ↑n ↔ (coeff R n) φ ≠ 0 ∧ ∀ i < n, (coeff R i) φ = 0
state_after: case inl
R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
n : ℕ
⊢ order 0 = ↑n ↔ (coeff R n) 0 ≠ 0 ∧ ∀ i < n, (coeff R i) 0 = 0

case inr
R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
hφ : φ ≠ 0
⊢ φ.order = ↑n ↔ (coeff R n) φ ≠ 0 ∧ ∀ i < n, (coeff R i) φ = 0

tactic: simp [order, dif_neg hφ, Nat.find_eq_iff]
state_before: case inr
R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
hφ : φ ≠ 0
⊢ φ.order = ↑n ↔ (coeff R n) φ ≠ 0 ∧ ∀ i < n, (coeff R i) φ = 0
state_after: no goals

tactic: simpa [(coeff R _).map_zero] using (PartENat.natCast_ne_top _).symm
state_before: case inl
R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
n : ℕ
⊢ order 0 = ↑n ↔ (coeff R n) 0 ≠ 0 ∧ ∀ i < n, (coeff R i) 0 = 0
state_after: no goals
Theorem: selfZPow_zero
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: simp [selfZPow_of_nonneg _ _ le_rfl]
state_before: R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
⊢ selfZPow x B 0 = 1
state_after: no goals
Theorem: map_mem_minimals_iff
File: Mathlib/Order/Minimal.lean

tactic: simpa only [hf h' ha, hf ha h'] using hmin ⟨a', h', rfl⟩
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a✝ b : α
inst✝ : PartialOrder α
f : α → β
r : α → α → Prop
s : β → β → Prop
x : Set α
hf : ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))
a : α
ha : a ∈ x
x✝ : f a ∈ minimals s (f '' x)
left✝ : f a ∈ f '' x
hmin : ∀ ⦃b : β⦄, b ∈ f '' x → s b (f a) → s (f a) b
a' : α
h' : a' ∈ x
⊢ r a' a → r a a'
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isRat_sub
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [hf, sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ IsRat (f a b) nc dc
state_after: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ IsRat (a + -b) nc dc

tactic: refine isRat_add rfl ra (isRat_neg (n' := -nb) rfl rb rfl) (k := k) (nc := nc) ?_ h₂
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ IsRat (a + -b) nc dc
state_after: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ (na.mul ↑db).add ((-nb).mul ↑da) = (↑k).mul nc

tactic: rw [show Int.mul (-nb) _ = _ from neg_mul ..]
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ (na.mul ↑db).add ((-nb).mul ↑da) = (↑k).mul nc
state_after: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ (na.mul ↑db).add (-(nb * ↑da)) = (↑k).mul nc

tactic: exact h₁
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : (na.mul ↑db).sub (nb.mul ↑da) = (↑k).mul nc
h₂ : da.mul db = k.mul dc
⊢ (na.mul ↑db).add (-(nb * ↑da)) = (↑k).mul nc
state_after: no goals
Theorem: Finset.sum_filter_count_eq_countP
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simp [Finset.sum, sum_map_count_dedup_filter_eq_countP p l]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
l : List α
⊢ ∑ x ∈ filter p l.toFinset, count x l = countP (fun b => decide (p b)) l
state_after: no goals
Theorem: ProbabilityTheory.kernel.compProd_fst_condKernelUnitReal
File: Mathlib/Probability/Kernel/Disintegration/Basic.lean

tactic: rw [condKernelUnitReal, compProd_toKernel]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel Unit (α × ℝ))
inst✝ : IsFiniteKernel κ
⊢ fst κ ⊗ₖ condKernelUnitReal κ = κ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel Unit (α × ℝ))
inst✝ : IsFiniteKernel κ
⊢ const Unit (κ ()) = κ

tactic: ext a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel Unit (α × ℝ))
inst✝ : IsFiniteKernel κ
⊢ const Unit (κ ()) = κ
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel Unit (α × ℝ))
inst✝ : IsFiniteKernel κ
a : Unit
s✝ : Set (α × ℝ)
a✝ : MeasurableSet s✝
⊢ ((const Unit (κ ())) a) s✝ = (κ a) s✝

tactic: simp
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel Unit (α × ℝ))
inst✝ : IsFiniteKernel κ
a : Unit
s✝ : Set (α × ℝ)
a✝ : MeasurableSet s✝
⊢ ((const Unit (κ ())) a) s✝ = (κ a) s✝
state_after: no goals
Theorem: Real.hasDerivAt_Gamma_one
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

tactic: simpa only [factorial_zero, cast_one, harmonic_zero, Rat.cast_zero, add_zero, mul_neg, one_mul,
  cast_zero, zero_add] using hasDerivAt_Gamma_nat 0
state_before: ⊢ HasDerivAt Gamma (-γ) 1
state_after: no goals
Theorem: MeasureTheory.sum_addContent_le_of_subset
File: Mathlib/MeasureTheory/Measure/AddContent.lean

tactic: classical
rw [addContent_eq_add_diffFinset₀_of_subset hC ht h_ss hJt h_dis]
exact le_add_right le_rfl
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hC : IsSetSemiring C
h_ss : ↑I ⊆ C
h_dis : (↑I).PairwiseDisjoint id
ht : t ∈ C
hJt : ∀ s ∈ I, s ⊆ t
⊢ ∑ u ∈ I, m u ≤ m t
state_after: no goals

tactic: rw [addContent_eq_add_diffFinset₀_of_subset hC ht h_ss hJt h_dis]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hC : IsSetSemiring C
h_ss : ↑I ⊆ C
h_dis : (↑I).PairwiseDisjoint id
ht : t ∈ C
hJt : ∀ s ∈ I, s ⊆ t
⊢ ∑ u ∈ I, m u ≤ m t
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hC : IsSetSemiring C
h_ss : ↑I ⊆ C
h_dis : (↑I).PairwiseDisjoint id
ht : t ∈ C
hJt : ∀ s ∈ I, s ⊆ t
⊢ ∑ u ∈ I, m u ≤ ∑ i ∈ I, m i + ∑ i ∈ hC.diffFinset₀ ht h_ss, m i

tactic: exact le_add_right le_rfl
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m m' : AddContent C
hC : IsSetSemiring C
h_ss : ↑I ⊆ C
h_dis : (↑I).PairwiseDisjoint id
ht : t ∈ C
hJt : ∀ s ∈ I, s ⊆ t
⊢ ∑ u ∈ I, m u ≤ ∑ i ∈ I, m i + ∑ i ∈ hC.diffFinset₀ ht h_ss, m i
state_after: no goals
Theorem: Real.sinh_add_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [add_comm, cosh_add_sinh]
state_before: x y : ℝ
⊢ sinh x + cosh x = rexp x
state_after: no goals
Theorem: Real.tendsto_of_bddBelow_antitone
File: Mathlib/Topology/Instances/NNReal.lean

tactic: obtain ⟨B, hB⟩ := Real.exists_isGLB (Set.range_nonempty f) h_bdd
state_before: f : ℕ → ℝ
h_bdd : BddBelow (range f)
h_ant : Antitone f
⊢ ∃ r, Tendsto f atTop (𝓝 r)
state_after: case intro
f : ℕ → ℝ
h_bdd : BddBelow (range f)
h_ant : Antitone f
B : ℝ
hB : IsGLB (range f) B
⊢ ∃ r, Tendsto f atTop (𝓝 r)

tactic: exact ⟨B, tendsto_atTop_isGLB h_ant hB⟩
state_before: case intro
f : ℕ → ℝ
h_bdd : BddBelow (range f)
h_ant : Antitone f
B : ℝ
hB : IsGLB (range f) B
⊢ ∃ r, Tendsto f atTop (𝓝 r)
state_after: no goals
Theorem: Finset.coe_biUnion
File: Mathlib/Data/Finset/Union.lean

tactic: simp [Set.ext_iff, mem_biUnion, Set.mem_iUnion, iff_self_iff, mem_coe, imp_true_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
⊢ ↑(s.biUnion t) = ⋃ x ∈ ↑s, ↑(t x)
state_after: no goals
Theorem: mem_sphere_one_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp [dist_eq_norm_div]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ a ∈ sphere 1 r ↔ ‖a‖ = r
state_after: no goals
Theorem: Cardinal.two_le_iff_one_lt
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: convert natCast_add_one_le_iff
state_before: α β : Type u
c : Cardinal.{u_1}
⊢ 2 ≤ c ↔ 1 < c
state_after: case h.e'_1.h.e'_3
α β : Type u
c : Cardinal.{u_1}
⊢ 2 = ↑1 + 1

tactic: norm_cast
state_before: case h.e'_1.h.e'_3
α β : Type u
c : Cardinal.{u_1}
⊢ 2 = ↑1 + 1
state_after: no goals
Theorem: WeierstrassCurve.baseChange_preΨ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: rw [← map_preΨ, map_baseChange]
state_before: R : Type r
S : Type s
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
W : WeierstrassCurve R
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
n : ℤ
⊢ (W.baseChange B).preΨ n = Polynomial.map (↑f) ((W.baseChange A).preΨ n)
state_after: no goals
Theorem: Submodule.set_smul_le_iff
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

tactic: fconstructor
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
⊢ s • N ≤ p ↔ ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p
state_after: case mp
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
⊢ s • N ≤ p → ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p

case mpr
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
⊢ (∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p) → s • N ≤ p

tactic: intro h r n hr hn
state_before: case mp
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
⊢ s • N ≤ p → ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p
state_after: case mp
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
h : s • N ≤ p
r : S
n : M
hr : r ∈ s
hn : n ∈ N
⊢ r • n ∈ p

tactic: exact h <| mem_set_smul_of_mem_mem hr hn
state_before: case mp
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
h : s • N ≤ p
r : S
n : M
hr : r ∈ s
hn : n ∈ N
⊢ r • n ∈ p
state_after: no goals

tactic: apply set_smul_le
state_before: case mpr
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s : Set S
N p : Submodule R M
⊢ (∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p) → s • N ≤ p
state_after: no goals
Theorem: String.next_of_valid'
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp only [next, get_of_valid]
state_before: cs cs' : List Char
⊢ { data := cs ++ cs' }.next { byteIdx := utf8Len cs } = { byteIdx := utf8Len cs + (cs'.headD default).utf8Size }
state_after: cs cs' : List Char
⊢ { byteIdx := utf8Len cs } + cs'.headD default = { byteIdx := utf8Len cs + (cs'.headD default).utf8Size }

tactic: rfl
state_before: cs cs' : List Char
⊢ { byteIdx := utf8Len cs } + cs'.headD default = { byteIdx := utf8Len cs + (cs'.headD default).utf8Size }
state_after: no goals
Theorem: LieIdeal.comap_bracket_incl
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: conv_rhs =>
  congr
  next => skip
  rw [← I.incl_idealRange]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I ⊓ I₁, I ⊓ I₂⁆
state_after: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I.incl.idealRange ⊓ I₁, I.incl.idealRange ⊓ I₂⁆

tactic: rw [comap_bracket_eq]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap I.incl I₁, comap I.incl I₂⁆ = comap I.incl ⁅I.incl.idealRange ⊓ I₁, I.incl.idealRange ⊓ I₂⁆
state_after: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap I.incl I₁, comap I.incl I₂⁆ = ⁅comap I.incl I₁, comap I.incl I₂⁆ ⊔ I.incl.ker

R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ I.incl.IsIdealMorphism

tactic: simp only [ker_incl, sup_bot_eq]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap I.incl I₁, comap I.incl I₂⁆ = ⁅comap I.incl I₁, comap I.incl I₂⁆ ⊔ I.incl.ker
state_after: no goals

tactic: exact I.incl_isIdealMorphism
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ I.incl.IsIdealMorphism
state_after: no goals
Theorem: Matrix.mul_eq_one_comm
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI : Invertible B.det := detInvertibleOfLeftInverse _ _ h
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
⊢ B * A = 1
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this : Invertible B.det := B.detInvertibleOfLeftInverse A h
⊢ B * A = 1

tactic: letI : Invertible B := invertibleOfDetInvertible B
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this : Invertible B.det := B.detInvertibleOfLeftInverse A h
⊢ B * A = 1
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this✝ : Invertible B.det := B.detInvertibleOfLeftInverse A h
this : Invertible B := B.invertibleOfDetInvertible
⊢ B * A = 1

tactic: calc
  B * A = B * A * (B * ⅟ B) := by rw [mul_invOf_self, Matrix.mul_one]
  _ = B * (A * B * ⅟ B) := by simp only [Matrix.mul_assoc]
  _ = B * ⅟ B := by rw [h, Matrix.one_mul]
  _ = 1 := mul_invOf_self B
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this✝ : Invertible B.det := B.detInvertibleOfLeftInverse A h
this : Invertible B := B.invertibleOfDetInvertible
⊢ B * A = 1
state_after: no goals

tactic: rw [mul_invOf_self, Matrix.mul_one]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this✝ : Invertible B.det := B.detInvertibleOfLeftInverse A h
this : Invertible B := B.invertibleOfDetInvertible
⊢ B * A = B * A * (B * ⅟B)
state_after: no goals

tactic: simp only [Matrix.mul_assoc]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this✝ : Invertible B.det := B.detInvertibleOfLeftInverse A h
this : Invertible B := B.invertibleOfDetInvertible
⊢ B * A * (B * ⅟B) = B * (A * B * ⅟B)
state_after: no goals

tactic: rw [h, Matrix.one_mul]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : A * B = 1
this✝ : Invertible B.det := B.detInvertibleOfLeftInverse A h
this : Invertible B := B.invertibleOfDetInvertible
⊢ B * (A * B * ⅟B) = B * ⅟B
state_after: no goals
Theorem: MeasureTheory.snorm_le_snorm_mul_snorm_top
File: Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean

tactic: simpa only [mul_comm] using h
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ : Measure α
f✝ : α → E
g✝ : α → F
p : ℝ≥0∞
f : α → E
hf : AEStronglyMeasurable f μ
g : α → F
b : E → F → G
h : ∀ᵐ (x : α) ∂μ, ‖b (f x) (g x)‖₊ ≤ ‖f x‖₊ * ‖g x‖₊
⊢ ∀ᵐ (x : α) ∂μ, ‖flip b (g x) (f x)‖₊ ≤ ‖g x‖₊ * ‖f x‖₊
state_after: no goals