1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.FinStronglyMeasurable.const_smul
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine ⟨fun n => c • hf.approx n, fun n => ?_, fun x => (hf.tendsto_approx x).const_smul c⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
⊢ FinStronglyMeasurable (c • f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support ↑((fun n => c • hf.approx n) n)) < ⊤

tactic: rw [SimpleFunc.coe_smul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support ↑((fun n => c • hf.approx n) n)) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support (c • ↑(hf.approx n))) < ⊤

tactic: exact (measure_mono (support_const_smul_subset c _)).trans_lt (hf.fin_support_approx n)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support (c • ↑(hf.approx n))) < ⊤
state_after: no goals
Theorem: Complex.cpow_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp only [cpow_def, neg_eq_zero, mul_neg]
state_before: x y : ℂ
⊢ x ^ (-y) = (x ^ y)⁻¹
state_after: x y : ℂ
⊢ (if x = 0 then if y = 0 then 1 else 0 else cexp (-(log x * y))) =
    (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y))⁻¹

tactic: split_ifs <;> simp [exp_neg]
state_before: x y : ℂ
⊢ (if x = 0 then if y = 0 then 1 else 0 else cexp (-(log x * y))) =
    (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y))⁻¹
state_after: no goals
Theorem: Ideal.isUnit_of_sub_one_mem_jacobson_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: cases' exists_mul_sub_mem_of_sub_one_mem_jacobson r h with s hs
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
r : R
h : r - 1 ∈ ⊥.jacobson
⊢ IsUnit r
state_after: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
r : R
h : r - 1 ∈ ⊥.jacobson
s : R
hs : s * r - 1 ∈ ⊥
⊢ IsUnit r

tactic: rw [mem_bot, sub_eq_zero, mul_comm] at hs
state_before: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
r : R
h : r - 1 ∈ ⊥.jacobson
s : R
hs : s * r - 1 ∈ ⊥
⊢ IsUnit r
state_after: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
r : R
h : r - 1 ∈ ⊥.jacobson
s : R
hs : r * s = 1
⊢ IsUnit r

tactic: exact isUnit_of_mul_eq_one _ _ hs
state_before: case intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
r : R
h : r - 1 ∈ ⊥.jacobson
s : R
hs : r * s = 1
⊢ IsUnit r
state_after: no goals
Theorem: TypeVec.subtypeVal_diagSub
File: Mathlib/Data/TypeVec.lean

tactic: ext i x
state_before: n : ℕ
α : TypeVec.{u_1} n
⊢ subtypeVal α.repeatEq ⊚ diagSub = prod.diag
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x : α i
⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x

tactic: induction' i with _ _ _ i_ih
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x : α i
⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x
state_after: case a.h.fz
n n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x : α Fin2.fz
⊢ (subtypeVal α.repeatEq ⊚ diagSub) Fin2.fz x = prod.diag Fin2.fz x

case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝.fs x

tactic: simp [comp, diagSub, subtypeVal, prod.diag]
state_before: case a.h.fz
n n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x : α Fin2.fz
⊢ (subtypeVal α.repeatEq ⊚ diagSub) Fin2.fz x = prod.diag Fin2.fz x
state_after: no goals

tactic: simp [prod.diag]
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝.fs x
state_after: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝ x

tactic: simp? [comp, diagSub, subtypeVal, prod.diag] at * says
  simp only [comp, subtypeVal, diagSub] at *
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝ x
state_after: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), subtypeVal α.repeatEq a✝ (diagSub a✝ x) = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ subtypeVal (dropFun α.repeatEq) a✝ (diagSub a✝ x) = prod.diag a✝ x

tactic: apply @i_ih (drop _)
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), subtypeVal α.repeatEq a✝ (diagSub a✝ x) = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ subtypeVal (dropFun α.repeatEq) a✝ (diagSub a✝ x) = prod.diag a✝ x
state_after: no goals

tactic: simp only [comp, subtypeVal, diagSub] at *
state_before: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝ x
state_after: case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), subtypeVal α.repeatEq a✝ (diagSub a✝ x) = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ subtypeVal (dropFun α.repeatEq) a✝ (diagSub a✝ x) = prod.diag a✝ x
Theorem: Rat.divInt_one_one
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [divInt_one]
state_before: q a b c : ℚ
⊢ 1 /. 1 = 1
state_after: q a b c : ℚ
⊢ ↑1 = 1

tactic: rfl
state_before: q a b c : ℚ
⊢ ↑1 = 1
state_after: no goals
Theorem: ContinuousMultilinearMap.isLeast_opNNNorm
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

tactic: simpa only [← opNNNorm_le_iff] using isLeast_Ici
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
⊢ IsLeast {C | ∀ (m : (i : ι) → E i), ‖f m‖₊ ≤ C * ∏ i : ι, ‖m i‖₊} ‖f‖₊
state_after: no goals
Theorem: ContinuousLinearMap.toContinuousAffineMap_map_zero
File: Mathlib/Topology/Algebra/ContinuousAffineMap.lean

tactic: simp
state_before: R : Type u_1
V : Type u_2
W : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : TopologicalSpace V
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : TopologicalSpace W
f : V →L[R] W
⊢ f.toContinuousAffineMap 0 = 0
state_after: no goals
Theorem: Rat.sqrt_natCast
File: Mathlib/Data/Rat/Sqrt.lean

tactic: rw [← Int.cast_natCast, sqrt_intCast, Int.sqrt_natCast, Int.cast_natCast]
state_before: n : ℕ
⊢ sqrt ↑n = ↑n.sqrt
state_after: no goals
Theorem: Affine.Simplex.range_face_points
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [face_points', Set.range_comp, Finset.range_orderEmbOfFin]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
fs : Finset (Fin (n + 1))
m : ℕ
h : fs.card = m + 1
⊢ Set.range (s.face h).points = s.points '' ↑fs
state_after: no goals
Theorem: hasStrictFDerivAt_id
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
x : E
⊢ ∀ (x : E × E), 0 = _root_.id x.1 - _root_.id x.2 - (ContinuousLinearMap.id 𝕜 E) (x.1 - x.2)
state_after: no goals
Theorem: Submodule.mem_span_singleton_mul
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rfl
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n x y : A
⊢ x ∈ map ((LinearMap.mul R A) y) P ↔ ∃ z ∈ P, Mul.mul y z = x
state_after: no goals
Theorem: CategoryTheory.IsIso.of_isIso_comp_right
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← comp_id f, ← hom_inv_id g, ← assoc]
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso g
inst✝ : IsIso (f ≫ g)
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso g
inst✝ : IsIso (f ≫ g)
⊢ IsIso ((f ≫ g) ≫ inv g)

tactic: infer_instance
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso g
inst✝ : IsIso (f ≫ g)
⊢ IsIso ((f ≫ g) ≫ inv g)
state_after: no goals
Theorem: hnot_sdiff
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← top_sdiff', sdiff_sdiff, sup_idem]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b c a : α
⊢ ￢a \ a = ￢a
state_after: no goals
Theorem: MvPolynomial.NewtonIdentities.sum_filter_pairs_eq_sum_filter_antidiagonal_powersetCard_sum
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

tactic: rw [filter_pairs_lt, sum_product, sum_disjiUnion]
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ t ∈ filter (fun t => t.1.card < k) (MvPolynomial.NewtonIdentities.pairs σ k), f t =
    ∑ a ∈ filter (fun a => a.1 < k) (antidiagonal k), ∑ A ∈ powersetCard a.1 univ, ∑ j : σ, f (A, j)
state_after: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ i ∈ range k, ∑ x ∈ powersetCard i univ, ∑ y : σ, f (x, y) =
    ∑ a ∈ filter (fun a => a.1 < k) (antidiagonal k), ∑ A ∈ powersetCard a.1 univ, ∑ j : σ, f (A, j)

tactic: refine sum_nbij' (fun n ↦ (n, k - n)) Prod.fst ?_ ?_ ?_ ?_ ?_ <;>
  simp (config := { contextual := true }) [@eq_comm _ _ k, Nat.add_sub_cancel', le_of_lt]
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ i ∈ range k, ∑ x ∈ powersetCard i univ, ∑ y : σ, f (x, y) =
    ∑ a ∈ filter (fun a => a.1 < k) (antidiagonal k), ∑ A ∈ powersetCard a.1 univ, ∑ j : σ, f (A, j)
state_after: no goals
Theorem: MeasureTheory.integrable_add_iff_integrable_right
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [add_neg_cancel_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → β
hf : Integrable f μ
h : Integrable (f + g) μ
⊢ g = f + g + -f
state_after: no goals
Theorem: AddMonoidAlgebra.induction_on
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: refine Finsupp.induction_linear f ?_ (fun f g hf hg => hadd f g hf hg) fun g r => ?_
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
⊢ p f
state_after: case refine_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
⊢ p 0

case refine_2
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
g : G
r : k
⊢ p (Finsupp.single g r)

tactic: simpa using hsmul 0 (of k G (Multiplicative.ofAdd 0)) (hM 0)
state_before: case refine_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
⊢ p 0
state_after: no goals

tactic: convert hsmul r (of k G (Multiplicative.ofAdd g)) (hM g)
state_before: case refine_2
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
g : G
r : k
⊢ p (Finsupp.single g r)
state_after: case h.e'_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
g : G
r : k
⊢ Finsupp.single g r = r • (of k G) (Multiplicative.ofAdd g)

tactic: rw [of_apply, toAdd_ofAdd, smul_single', mul_one]
state_before: case h.e'_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
p : k[G] → Prop
f : k[G]
hM : ∀ (g : G), p ((of k G) (Multiplicative.ofAdd g))
hadd : ∀ (f g : k[G]), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : k[G]), p f → p (r • f)
g : G
r : k
⊢ Finsupp.single g r = r • (of k G) (Multiplicative.ofAdd g)
state_after: no goals
Theorem: LinearMap.det_eq_det_toMatrix_of_finset
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: have : ∃ s : Finset M, Nonempty (Basis s A M) := ⟨s, ⟨b⟩⟩
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
s : Finset M
b : Basis { x // x ∈ s } A M
f : M →ₗ[A] M
⊢ LinearMap.det f = ((toMatrix b b) f).det
state_after: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
s : Finset M
b : Basis { x // x ∈ s } A M
f : M →ₗ[A] M
this : ∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ LinearMap.det f = ((toMatrix b b) f).det

tactic: rw [LinearMap.coe_det, dif_pos, detAux_def'' _ b] <;> assumption
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
s : Finset M
b : Basis { x // x ∈ s } A M
f : M →ₗ[A] M
this : ∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ LinearMap.det f = ((toMatrix b b) f).det
state_after: no goals
Theorem: Ideal.exists_mul_sub_mem_of_sub_one_mem_jacobson
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: cases' mem_jacobson_iff.1 h 1 with s hs
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I : Ideal R
r : R
h : r - 1 ∈ I.jacobson
⊢ ∃ s, s * r - 1 ∈ I
state_after: case intro
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I : Ideal R
r : R
h : r - 1 ∈ I.jacobson
s : R
hs : s * 1 * (r - 1) + s - 1 ∈ I
⊢ ∃ s, s * r - 1 ∈ I

tactic: use s
state_before: case intro
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I : Ideal R
r : R
h : r - 1 ∈ I.jacobson
s : R
hs : s * 1 * (r - 1) + s - 1 ∈ I
⊢ ∃ s, s * r - 1 ∈ I
state_after: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I : Ideal R
r : R
h : r - 1 ∈ I.jacobson
s : R
hs : s * 1 * (r - 1) + s - 1 ∈ I
⊢ s * r - 1 ∈ I

tactic: simpa [mul_sub] using hs
state_before: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I : Ideal R
r : R
h : r - 1 ∈ I.jacobson
s : R
hs : s * 1 * (r - 1) + s - 1 ∈ I
⊢ s * r - 1 ∈ I
state_after: no goals
Theorem: Bool.toNat_beq_zero
File: Mathlib/Data/Bool/Basic.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b.toNat == 0) = !b
state_after: no goals
Theorem: Finset.filter_ge_eq_Iic
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x ≤ a
⊢ filter (fun x => x ≤ a) univ = Iic a
state_after: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x ≤ a
a✝ : α
⊢ a✝ ∈ filter (fun x => x ≤ a) univ ↔ a✝ ∈ Iic a

tactic: simp
state_before: case a
ι : Type u_1
α : Type u_2
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x ≤ a
a✝ : α
⊢ a✝ ∈ filter (fun x => x ≤ a) univ ↔ a✝ ∈ Iic a
state_after: no goals
Theorem: lt_update_self_iff
File: Mathlib/Order/Basic.lean

tactic: simp [lt_iff_le_not_le]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Preorder (π i)
x y : (i : ι) → π i
i : ι
a b : π i
⊢ x < update x i a ↔ x i < a
state_after: no goals
Theorem: Int.Matrix.one_le_norm_A_of_ne_zero
File: Mathlib/NumberTheory/SiegelsLemma.lean

tactic: by_contra! h
state_before: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
⊢ 1 ≤ ‖A‖
state_after: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
⊢ False

tactic: apply hA
state_before: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
⊢ False
state_after: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
⊢ A = 0

tactic: ext i j
state_before: m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
⊢ A = 0
state_after: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
i : Fin m
j : Fin n
⊢ A i j = 0 i j

tactic: simp only [zero_apply]
state_before: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
i : Fin m
j : Fin n
⊢ A i j = 0 i j
state_after: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
i : Fin m
j : Fin n
⊢ A i j = 0

tactic: rw [norm_lt_iff Real.zero_lt_one] at h
state_before: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ‖A‖ < 1
i : Fin m
j : Fin n
⊢ A i j = 0
state_after: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ∀ (i : Fin m) (j : Fin n), ‖A i j‖ < 1
i : Fin m
j : Fin n
⊢ A i j = 0

tactic: specialize h i j
state_before: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
h : ∀ (i : Fin m) (j : Fin n), ‖A i j‖ < 1
i : Fin m
j : Fin n
⊢ A i j = 0
state_after: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
i : Fin m
j : Fin n
h : ‖A i j‖ < 1
⊢ A i j = 0

tactic: rw [Int.norm_eq_abs] at h
state_before: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
i : Fin m
j : Fin n
h : ‖A i j‖ < 1
⊢ A i j = 0
state_after: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
i : Fin m
j : Fin n
h : |↑(A i j)| < 1
⊢ A i j = 0

tactic: norm_cast at h
state_before: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
i : Fin m
j : Fin n
h : |↑(A i j)| < 1
⊢ A i j = 0
state_after: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
i : Fin m
j : Fin n
h : |A i j| < 1
⊢ A i j = 0

tactic: exact Int.abs_lt_one_iff.1 h
state_before: case a
m n : ℕ
A : Matrix (Fin m) (Fin n) ℤ
v : Fin n → ℤ
hn : m < n
hm : 0 < m
hA : A ≠ 0
i : Fin m
j : Fin n
h : |A i j| < 1
⊢ A i j = 0
state_after: no goals
Theorem: uniformity_lift_le_comp
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [lift_lift'_assoc]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Set (α × α) → Filter β
h : Monotone f
⊢ ((𝓤 α).lift fun s => f (s ○ s)) = ((𝓤 α).lift' fun s => s ○ s).lift f
state_after: case hg
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Set (α × α) → Filter β
h : Monotone f
⊢ Monotone fun s => s ○ s

case hh
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Set (α × α) → Filter β
h : Monotone f
⊢ Monotone f

tactic: exact monotone_id.compRel monotone_id
state_before: case hg
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Set (α × α) → Filter β
h : Monotone f
⊢ Monotone fun s => s ○ s
state_after: no goals

tactic: exact h
state_before: case hh
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Set (α × α) → Filter β
h : Monotone f
⊢ Monotone f
state_after: no goals
Theorem: Finset.image_swap_product
File: Mathlib/Data/Finset/Prod.lean

tactic: push_cast
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
inst✝ : DecidableEq (α × β)
s : Finset α
t : Finset β
⊢ ↑(image Prod.swap (t ×ˢ s)) = ↑(s ×ˢ t)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
inst✝ : DecidableEq (α × β)
s : Finset α
t : Finset β
⊢ Prod.swap '' ↑t ×ˢ ↑s = ↑s ×ˢ ↑t

tactic: exact Set.image_swap_prod _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
inst✝ : DecidableEq (α × β)
s : Finset α
t : Finset β
⊢ Prod.swap '' ↑t ×ˢ ↑s = ↑s ×ˢ ↑t
state_after: no goals