1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Projectivization.dependent_pair_iff_eq
File: Mathlib/LinearAlgebra/Projectivization/Independence.lean

tactic: rw [dependent_iff_not_independent, independent_iff, linearIndependent_fin2,
  Function.comp_apply, Matrix.cons_val_one, Matrix.head_cons, Ne]
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ Dependent ![u, v] ↔ u = v
state_after: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬(¬v.rep = 0 ∧ ∀ (a : K), a • v.rep ≠ (Projectivization.rep ∘ ![u, v]) 0) ↔ u = v

tactic: simp only [Matrix.cons_val_zero, not_and, not_forall, Classical.not_not, Function.comp_apply,
  ← mk_eq_mk_iff' K _ _ (rep_nonzero u) (rep_nonzero v), mk_rep, Classical.imp_iff_right_iff]
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬(¬v.rep = 0 ∧ ∀ (a : K), a • v.rep ≠ (Projectivization.rep ∘ ![u, v]) 0) ↔ u = v
state_after: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬v.rep = 0 ∨ u = v

tactic: exact Or.inl (rep_nonzero v)
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬v.rep = 0 ∨ u = v
state_after: no goals
Theorem: MeasureTheory.Measure.haar.is_left_invariant_haarContent
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simpa only [ENNReal.coe_inj, ← NNReal.coe_inj, haarContent_apply] using
  is_left_invariant_chaar g K
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
g : G
K : Compacts G
⊢ (fun s => ↑((haarContent K₀).toFun s)) (Compacts.map (fun b => g * b) ⋯ K) = (fun s => ↑((haarContent K₀).toFun s)) K
state_after: no goals
Theorem: Basis.prod_apply_inl_snd
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext j
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι
⊢ b'.repr ((b.prod b') (Sum.inl i)).2 = b'.repr 0
state_after: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι
j : ι'
⊢ (b'.repr ((b.prod b') (Sum.inl i)).2) j = (b'.repr 0) j

tactic: simp only [Basis.prod, Basis.coe_ofRepr, LinearEquiv.symm_trans_apply, LinearEquiv.prod_symm,
  LinearEquiv.prod_apply, b'.repr.apply_symm_apply, LinearEquiv.symm_symm, repr_self,
  Equiv.toFun_as_coe, Finsupp.snd_sumFinsuppLEquivProdFinsupp, LinearEquiv.map_zero,
  Finsupp.zero_apply]
state_before: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι
j : ι'
⊢ (b'.repr ((b.prod b') (Sum.inl i)).2) j = (b'.repr 0) j
state_after: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι
j : ι'
⊢ (Finsupp.single (Sum.inl i) 1) (Sum.inr j) = 0

tactic: apply Finsupp.single_eq_of_ne Sum.inl_ne_inr
state_before: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι
j : ι'
⊢ (Finsupp.single (Sum.inl i) 1) (Sum.inr j) = 0
state_after: no goals
Theorem: Set.diagonal_eq_univ_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp only [subsingleton_iff, eq_univ_iff_forall, Prod.forall, mem_diagonal_iff]
state_before: α : Type u_1
s t : Set α
⊢ diagonal α = univ ↔ Subsingleton α
state_after: no goals
Theorem: Finset.card_div_mul_le_card_mul_mul_card_mul
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [← div_inv_eq_mul, ← card_inv B, ← card_inv (B * C), mul_inv, ← div_eq_mul_inv]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ (A * B).card * (B * C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B⁻¹.card ≤ (A / B⁻¹).card * (B⁻¹ / C).card

tactic: exact card_div_mul_le_card_div_mul_card_div _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B⁻¹.card ≤ (A / B⁻¹).card * (B⁻¹ / C).card
state_after: no goals
Theorem: IsTorsionFree.subgroup
File: Mathlib/GroupTheory/Torsion.lean

tactic: norm_cast
state_before: G : Type u_1
H✝ : Type u_2
inst✝ : Group G
tG : IsTorsionFree G
H : Subgroup G
h : ↥H
hne : h ≠ 1
⊢ ↑h ≠ 1
state_after: no goals
Theorem: edist_le_of_edist_le_geometric_two_of_tendsto₀
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simpa only [_root_.pow_zero, div_eq_mul_inv, inv_one, mul_one] using
  edist_le_of_edist_le_geometric_two_of_tendsto C hu ha 0
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C / 2 ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
⊢ edist (f 0) a ≤ 2 * C
state_after: no goals
Theorem: SimpleGraph.Walk.transfer_transfer
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ _ ih =>
  simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
  apply ih
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H : SimpleGraph V
hp : ∀ e ∈ p.edges, e ∈ H.edgeSet
K : SimpleGraph V
hp' : ∀ e ∈ (p.transfer H hp).edges, e ∈ K.edgeSet
⊢ (p.transfer H hp).transfer K hp' = p.transfer K ⋯
state_after: no goals

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H K : SimpleGraph V
u✝ : V
hp : ∀ e ∈ nil.edges, e ∈ H.edgeSet
hp' : ∀ e ∈ (nil.transfer H hp).edges, e ∈ K.edgeSet
⊢ (nil.transfer H hp).transfer K hp' = nil.transfer K ⋯
state_after: no goals

tactic: simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H K : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ p✝.edges, e ∈ H.edgeSet) (hp' : ∀ e ∈ (p✝.transfer H hp).edges, e ∈ K.edgeSet),
    (p✝.transfer H hp).transfer K hp' = p✝.transfer K ⋯
hp : ∀ e ∈ (cons h✝ p✝).edges, e ∈ H.edgeSet
hp' : ∀ e ∈ ((cons h✝ p✝).transfer H hp).edges, e ∈ K.edgeSet
⊢ ((cons h✝ p✝).transfer H hp).transfer K hp' = (cons h✝ p✝).transfer K ⋯
state_after: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H K : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ p✝.edges, e ∈ H.edgeSet) (hp' : ∀ e ∈ (p✝.transfer H hp).edges, e ∈ K.edgeSet),
    (p✝.transfer H hp).transfer K hp' = p✝.transfer K ⋯
hp : ∀ e ∈ (cons h✝ p✝).edges, e ∈ H.edgeSet
hp' : ∀ e ∈ ((cons h✝ p✝).transfer H hp).edges, e ∈ K.edgeSet
⊢ (p✝.transfer H ⋯).transfer K ⋯ = p✝.transfer K ⋯

tactic: apply ih
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H K : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ p✝.edges, e ∈ H.edgeSet) (hp' : ∀ e ∈ (p✝.transfer H hp).edges, e ∈ K.edgeSet),
    (p✝.transfer H hp).transfer K hp' = p✝.transfer K ⋯
hp : ∀ e ∈ (cons h✝ p✝).edges, e ∈ H.edgeSet
hp' : ∀ e ∈ ((cons h✝ p✝).transfer H hp).edges, e ∈ K.edgeSet
⊢ (p✝.transfer H ⋯).transfer K ⋯ = p✝.transfer K ⋯
state_after: no goals
Theorem: Fin.castSucc_lt_or_lt_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [Fin.lt_def, -val_fin_lt]
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ i.castSucc < p ∨ p < i.succ
state_after: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑i < ↑p ∨ ↑p < ↑i + 1

tactic: omega
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑i < ↑p ∨ ↑p < ↑i + 1
state_after: no goals
Theorem: CategoryTheory.transferNatTransSelf_symm_comp
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: rw [Equiv.eq_symm_apply, ← transferNatTransSelf_comp _ adj₂]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₂ ⟶ R₁
g : R₃ ⟶ R₂
⊢ (transferNatTransSelf adj₂ adj₁).symm f ≫ (transferNatTransSelf adj₃ adj₂).symm g =
    (transferNatTransSelf adj₃ adj₁).symm (g ≫ f)
state_after: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₂ ⟶ R₁
g : R₃ ⟶ R₂
⊢ (transferNatTransSelf adj₃ adj₂) ((transferNatTransSelf adj₃ adj₂).symm g) ≫
      (transferNatTransSelf adj₂ adj₁) ((transferNatTransSelf adj₂ adj₁).symm f) =
    g ≫ f

tactic: simp
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₂ ⟶ R₁
g : R₃ ⟶ R₂
⊢ (transferNatTransSelf adj₃ adj₂) ((transferNatTransSelf adj₃ adj₂).symm g) ≫
      (transferNatTransSelf adj₂ adj₁) ((transferNatTransSelf adj₂ adj₁).symm f) =
    g ≫ f
state_after: no goals
Theorem: QuadraticForm.isOrtho_polarBilin
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp_rw [isOrtho_def, LinearMap.isOrtho_def, polarBilin_apply_apply, polar, sub_sub,
  sub_eq_zero]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : M
⊢ LinearMap.IsOrtho Q.polarBilin x y ↔ Q.IsOrtho x y
state_after: no goals
Theorem: ZFSet.Hereditarily.empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: apply @ZFSet.inductionOn _ x
state_before: p : ZFSet → Prop
x y : ZFSet
⊢ Hereditarily p x → p ∅
state_after: p : ZFSet → Prop
x y : ZFSet
⊢ ∀ (x : ZFSet), (∀ y ∈ x, Hereditarily p y → p ∅) → Hereditarily p x → p ∅

tactic: intro y IH h
state_before: p : ZFSet → Prop
x y : ZFSet
⊢ ∀ (x : ZFSet), (∀ y ∈ x, Hereditarily p y → p ∅) → Hereditarily p x → p ∅
state_after: p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
⊢ p ∅

tactic: rcases ZFSet.eq_empty_or_nonempty y with (rfl | ⟨a, ha⟩)
state_before: p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
⊢ p ∅
state_after: case inl
p : ZFSet → Prop
x y : ZFSet
IH : ∀ y ∈ ∅, Hereditarily p y → p ∅
h : Hereditarily p ∅
⊢ p ∅

case inr.intro
p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
a : ZFSet
ha : a ∈ y.toSet
⊢ p ∅

tactic: exact h.self
state_before: case inl
p : ZFSet → Prop
x y : ZFSet
IH : ∀ y ∈ ∅, Hereditarily p y → p ∅
h : Hereditarily p ∅
⊢ p ∅
state_after: no goals

tactic: exact IH a ha (h.mem ha)
state_before: case inr.intro
p : ZFSet → Prop
x y✝ y : ZFSet
IH : ∀ y_1 ∈ y, Hereditarily p y_1 → p ∅
h : Hereditarily p y
a : ZFSet
ha : a ∈ y.toSet
⊢ p ∅
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.LeftFraction.map_hom_ofInv_id
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: letI := hL _ hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ L.map s ≫ (ofInv s hs).map L hL = 𝟙 (L.obj Y)
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ L.map s ≫ (ofInv s hs).map L hL = 𝟙 (L.obj Y)

tactic: simp [map]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ L.map s ≫ (ofInv s hs).map L hL = 𝟙 (L.obj Y)
state_after: no goals
Theorem: PrimrecPred.or
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁶ : Primcodable α
inst✝⁵ : Primcodable β
inst✝⁴ : Primcodable γ
inst✝³ : Primcodable δ
inst✝² : Primcodable σ
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
hp : PrimrecPred p
hq : PrimrecPred q
n : α
⊢ (decide (p n) || decide (q n)) = decide ((fun a => p a ∨ q a) n)
state_after: no goals
Theorem: MeasureTheory.Measure.haar.prehaar_sup_le
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simp only [prehaar]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ prehaar (↑K₀) U (K₁ ⊔ K₂) ≤ prehaar (↑K₀) U K₁ + prehaar (↑K₀) U K₂
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)

tactic: rw [div_add_div_same, div_le_div_right]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) + ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) ≤ ↑(index (↑K₁) U) + ↑(index (↑K₂) U)

G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ 0 < ↑(index (↑K₀) U)

tactic: exact mod_cast index_union_le K₁ K₂ hU
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ ↑(index (↑(K₁ ⊔ K₂)) U) ≤ ↑(index (↑K₁) U) + ↑(index (↑K₂) U)
state_after: no goals

tactic: exact mod_cast index_pos K₀ hU
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
K₁ K₂ : Compacts G
hU : (interior U).Nonempty
⊢ 0 < ↑(index (↑K₀) U)
state_after: no goals
Theorem: preNormEDS'_odd
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: rw [show 2 * (m + 2) + 1 = 2 * m + 5 by rfl, preNormEDS', dif_pos <| even_two_mul _]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 2) + 1) =
    (preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * if Even m then b else 1) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * if Even m then 1 else b
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ ((preNormEDS' b c d (2 * m / 2 + 4) * preNormEDS' b c d (2 * m / 2 + 2) ^ 3 * if Even (2 * m / 2) then b else 1) -
      preNormEDS' b c d (2 * m / 2 + 1) * preNormEDS' b c d (2 * m / 2 + 3) ^ 3 * if Even (2 * m / 2) then 1 else b) =
    (preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * if Even m then b else 1) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * if Even m then 1 else b

tactic: simp only [m.mul_div_cancel_left two_pos]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ ((preNormEDS' b c d (2 * m / 2 + 4) * preNormEDS' b c d (2 * m / 2 + 2) ^ 3 * if Even (2 * m / 2) then b else 1) -
      preNormEDS' b c d (2 * m / 2 + 1) * preNormEDS' b c d (2 * m / 2 + 3) ^ 3 * if Even (2 * m / 2) then 1 else b) =
    (preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * if Even m then b else 1) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * if Even m then 1 else b
state_after: no goals

tactic: rfl
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ 2 * (m + 2) + 1 = 2 * m + 5
state_after: no goals
Theorem: sup_eq_left
File: Mathlib/Order/Lattice.lean

tactic: simp [le_rfl]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ⊔ b ≤ a ∧ a ≤ a ⊔ b ↔ b ≤ a
state_after: no goals
Theorem: Subgroup.sup_eq_closure_mul
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

tactic: rw [closure_eq, closure_eq]
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
H K : Subgroup G
⊢ closure ↑H ⊔ closure ↑K ≤ H ⊔ K
state_after: no goals
Theorem: sigma_mk_preimage_image'
File: Mathlib/Data/Set/Image.lean

tactic: simp [image, h]
state_before: α : Type u_1
β : α → Type u_2
i j : α
s : Set (β i)
h : i ≠ j
⊢ Sigma.mk j ⁻¹' (Sigma.mk i '' s) = ∅
state_after: no goals
Theorem: Finset.ordConnected_range_val
File: Mathlib/Data/Finset/Grade.lean

tactic: rintro _ _ _ ⟨s, rfl⟩ t ht
state_before: α : Type u_1
s t : Finset α
a : α
⊢ ∀ ⦃x : Multiset α⦄, x ∈ Set.range val → ∀ ⦃y : Multiset α⦄, y ∈ Set.range val → Set.Icc x y ⊆ Set.range val
state_after: case intro
α : Type u_1
s✝ t✝ : Finset α
a : α
x✝ : Multiset α
hx✝ : x✝ ∈ Set.range val
s : Finset α
t : Multiset α
ht : t ∈ Set.Icc x✝ s.val
⊢ t ∈ Set.range val

tactic: exact ⟨⟨t, Multiset.nodup_of_le ht.2 s.2⟩, rfl⟩
state_before: case intro
α : Type u_1
s✝ t✝ : Finset α
a : α
x✝ : Multiset α
hx✝ : x✝ ∈ Set.range val
s : Finset α
t : Multiset α
ht : t ∈ Set.Icc x✝ s.val
⊢ t ∈ Set.range val
state_after: no goals
Theorem: WType.cardinal_mk_eq_sum
File: Mathlib/Data/W/Cardinal.lean

tactic: simp_rw [lift_id]
state_before: α : Type u
β✝ : α → Type v
β : α → Type u
⊢ (sum fun a => #(WType β) ^ lift.{u, u} #(β a)) = sum fun a => #(WType β) ^ #(β a)
state_after: no goals
Theorem: SimpleGraph.cliqueSet_zero
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s✝ : Finset α
G : SimpleGraph α
s : Finset α
⊢ s ∈ G.cliqueSet 0 ↔ s ∈ {∅}
state_after: no goals
Theorem: TensorProduct.directSumRight_symm_lof_tmul
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

tactic: rw [LinearEquiv.symm_apply_eq, directSumRight_tmul_lof]
state_before: R : Type u
inst✝¹⁴ : CommSemiring R
S : Type ?u.154166
inst✝¹³ : Semiring S
inst✝¹² : Algebra R S
ι₁ : Type v₁
ι₂ : Type v₂
inst✝¹¹ : DecidableEq ι₁
inst✝¹⁰ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁹ : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)
inst✝⁸ : AddCommMonoid M₁'
inst✝⁷ : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)
inst✝⁶ : AddCommMonoid M₂'
inst✝⁵ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝⁴ : Module R M₁'
inst✝³ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝² : Module R M₂'
inst✝¹ : (i₁ : ι₁) → Module S (M₁ i₁)
inst✝ : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)
x : M₁'
i : ι₂
y : M₂ i
⊢ (directSumRight R M₁' M₂).symm ((lof R ι₂ (fun i => M₁' ⊗[R] M₂ i) i) (x ⊗ₜ[R] y)) = x ⊗ₜ[R] (lof R ι₂ M₂ i) y
state_after: no goals
Theorem: ModuleCat.MonoidalCategory.braiding_naturality_right
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Symmetric.lean

tactic: simp_rw [← id_tensorHom]
state_before: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
f : Y ⟶ Z
⊢ X ◁ f ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X
state_after: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
f : Y ⟶ Z
⊢ (𝟙 X ⊗ f) ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X

tactic: apply braiding_naturality
state_before: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
f : Y ⟶ Z
⊢ (𝟙 X ⊗ f) ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X
state_after: no goals
Theorem: lt_mul_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: convert mul_lt_mul_of_pos_left hm hn
state_before: α : Type u
β : Type u_1
inst✝ : StrictOrderedSemiring α
a b c d : α
hn : 0 < a
hm : 1 < b
⊢ a < a * b
state_after: case h.e'_3
α : Type u
β : Type u_1
inst✝ : StrictOrderedSemiring α
a b c d : α
hn : 0 < a
hm : 1 < b
⊢ a = a * 1

tactic: rw [mul_one]
state_before: case h.e'_3
α : Type u
β : Type u_1
inst✝ : StrictOrderedSemiring α
a b c d : α
hn : 0 < a
hm : 1 < b
⊢ a = a * 1
state_after: no goals
Theorem: MeasureTheory.union_cylinder
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: ext1 f
state_before: ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
⊢ cylinder s₁ S₁ ∪ cylinder s₂ S₂ = cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)
state_after: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ f ∈ cylinder s₁ S₁ ∪ cylinder s₂ S₂ ↔
    f ∈ cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)

tactic: simp only [mem_union, mem_cylinder, mem_setOf_eq]
state_before: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ f ∈ cylinder s₁ S₁ ∪ cylinder s₂ S₂ ↔
    f ∈ cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)
state_after: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ (fun i => f ↑i) ∈ S₁ ∨ (fun i => f ↑i) ∈ S₂ ↔
    (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∨ (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂

tactic: rfl
state_before: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ (fun i => f ↑i) ∈ S₁ ∨ (fun i => f ↑i) ∈ S₂ ↔
    (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∨ (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂
state_after: no goals
Theorem: MeasureTheory.IsFundamentalDomain.setLIntegral_eq_tsum
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp only [h.restrict_restrict, inter_comm]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
f : α → ℝ≥0∞
t : Set α
⊢ ∑' (g : G), ∫⁻ (x : α) in g • s, f x ∂μ.restrict t = ∑' (g : G), ∫⁻ (x : α) in t ∩ g • s, f x ∂μ
state_after: no goals
Theorem: tendsto_nhds_Prop
File: Mathlib/Topology/Order.lean

tactic: by_cases q <;> simp [*]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
l : Filter α
p : α → Prop
q : Prop
⊢ Tendsto p l (𝓝 q) ↔ q → ∀ᶠ (x : α) in l, p x
state_after: no goals