tasksource/leandojo huggingface dataset:
Theorem: HolderOnWith.comp
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: intro x hx y hy
state_before: X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
C r : ℝ≥0
f✝ : X → Y
s t✝ : Set X
Cg rg : ℝ≥0
g : Y → Z
t : Set Y
hg : HolderOnWith Cg rg g t
Cf rf : ℝ≥0
f : X → Y
hf : HolderOnWith Cf rf f s
hst : MapsTo f s t
⊢ HolderOnWith (Cg * NNReal.rpow Cf ↑rg) (rg * rf) (g ∘ f) s

tactic: rw [ENNReal.coe_mul, mul_comm rg, NNReal.coe_mul, ENNReal.rpow_mul, mul_assoc, NNReal.rpow_eq_pow,
  ← ENNReal.coe_rpow_of_nonneg _ rg.coe_nonneg, ← ENNReal.mul_rpow_of_nonneg _ _ rg.coe_nonneg]
state_before: X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
C r : ℝ≥0
f✝ : X → Y
s t✝ : Set X
Cg rg : ℝ≥0
g : Y → Z
t : Set Y
hg : HolderOnWith Cg rg g t
Cf rf : ℝ≥0
f : X → Y
hf : HolderOnWith Cf rf f s
hst : MapsTo f s t
x : X
hx : x ∈ s
y : X
hy : y ∈ s
⊢ edist ((g ∘ f) x) ((g ∘ f) y) ≤ ↑(Cg * NNReal.rpow Cf ↑rg) * edist x y ^ ↑(rg * rf)

tactic: exact hg.edist_le_of_le (hst hx) (hst hy) (hf.edist_le hx hy)
state_before: X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
C r : ℝ≥0
f✝ : X → Y
s t✝ : Set X
Cg rg : ℝ≥0
g : Y → Z
t : Set Y
hg : HolderOnWith Cg rg g t
Cf rf : ℝ≥0
f : X → Y
hf : HolderOnWith Cf rf f s
hst : MapsTo f s t
x : X
hx : x ∈ s
y : X
hy : y ∈ s
⊢ edist ((g ∘ f) x) ((g ∘ f) y) ≤ ↑Cg * (↑Cf * edist x y ^ ↑rf) ^ ↑rg
Theorem: Set.infsep_pair
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [infsep_pair_eq_toReal, edist_dist]
state_before: α : Type u_1
β : Type ?u.61000
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
⊢ infsep {x, y} = dist x y

tactic: exact ENNReal.toReal_ofReal dist_nonneg
state_before: α : Type u_1
β : Type ?u.61000
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
⊢ ENNReal.toReal (ENNReal.ofReal (dist x y)) = dist x y
Theorem: Basis.finTwoProd_one
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.finTwoProd, LinearEquiv.finTwoArrow]
state_before: ι : Type ?u.1086687
ι' : Type ?u.1086690
R✝ : Type ?u.1086693
R₂ : Type ?u.1086696
K : Type ?u.1086699
M : Type ?u.1086702
M' : Type ?u.1086705
M'' : Type ?u.1086708
V : Type u
V' : Type ?u.1086713
v : ι → M
inst✝⁹ : Ring R✝
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R✝ M
inst✝³ : Module R₂ M
inst✝² : Module R✝ M'
inst✝¹ : Module R✝ M''
c d : R✝
x y : M
b : Basis ι R✝ M
R : Type u_1
inst✝ : Semiring R
⊢ ↑(Basis.finTwoProd R) 1 = (0, 1)
Theorem: div_eq_div_iff_div_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_iff_eq_mul, div_mul_eq_mul_div, div_eq_iff_eq_mul', mul_div_assoc]
state_before: α : Type ?u.75761
β : Type ?u.75764
G : Type u_1
inst✝ : CommGroup G
a b c d : G
⊢ a / b = c / d ↔ a / c = b / d
Theorem: SimpleGraph.Walk.length_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
⊢ length (Walk.map f p) = length p
Theorem: AlternatingMap.coe_multilinearMap_mk
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: simp
state_before: R : Type u_4
inst✝¹⁰ : Semiring R
M : Type u_3
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
N : Type u_2
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
P : Type ?u.42102
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M' : Type ?u.42132
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
N' : Type ?u.42520
inst✝¹ : AddCommGroup N'
inst✝ : Module R N'
ι : Type u_1
ι' : Type ?u.42911
ι'' : Type ?u.42914
f✝ f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v : ι → M
v' : ι → M'
f : (ι → M) → N
h₁ :
  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M), f (update m i (x + y)) = f (update m i x) + f (update m i y)
h₂ : ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M), f (update m i (c • x)) = c • f (update m i x)
h₃ :
  ∀ (v : ι → M) (i j : ι),
    v i = v j →
      i ≠ j →
        MultilinearMap.toFun
            { toFun := f,
              map_add' :=
                (_ :
                  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                    f (update m i (x + y)) = f (update m i x) + f (update m i y)),
              map_smul' :=
                (_ :
                  ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                    f (update m i (c • x)) = c • f (update m i x)) }
            v =
          0
⊢ ↑{
        toMultilinearMap :=
          { toFun := f,
            map_add' :=
              (_ :
                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (x y : M),
                  f (update m i (x + y)) = f (update m i x) + f (update m i y)),
            map_smul' :=
              (_ :
                ∀ [inst : DecidableEq ι] (m : ι → M) (i : ι) (c : R) (x : M),
                  f (update m i (c • x)) = c • f (update m i x)) },
        map_eq_zero_of_eq' := h₃ } =
    { toFun := f, map_add' := h₁, map_smul' := h₂ }
Theorem: InnerProductSpace.Core.inner_self_eq_norm_mul_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [norm_eq_sqrt_inner, ← sqrt_mul inner_self_nonneg (re ⟪x, x⟫), sqrt_mul_self inner_self_nonneg]
state_before: 𝕜 : Type u_1
E : Type ?u.787535
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑re (inner x x) = ‖x‖ * ‖x‖
Theorem: iUnion_Ico_add_int_cast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [zsmul_one, Int.cast_add, Int.cast_one, ← add_assoc] using
  iUnion_Ico_add_zsmul zero_lt_one a
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ (⋃ (n : ℤ), Ico (a + ↑n) (a + ↑n + 1)) = univ
Theorem: CategoryTheory.Limits.prodZeroIso_iso_inv_snd
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [prodZeroIso, binaryFanZeroRight]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (prodZeroIso X).inv ≫ prod.fst = 𝟙 X

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (limit.isoLimitCone { cone := BinaryFan.mk (𝟙 X) 0, isLimit := binaryFanZeroRightIsLimit X }).inv ≫ prod.fst = 𝟙 X
Theorem: LinearMap.map_smul_inv
File: Mathlib/Algebra/Module/LinearMap.lean

tactic: simp
state_before: R : Type u_2
R₁ : Type ?u.133858
R₂ : Type ?u.133861
R₃ : Type ?u.133864
k : Type ?u.133867
S : Type u_1
S₃ : Type ?u.133873
T : Type ?u.133876
M : Type u_4
M₁ : Type ?u.133882
M₂ : Type ?u.133885
M₃ : Type u_3
N₁ : Type ?u.133891
N₂ : Type ?u.133894
N₃ : Type ?u.133897
ι : Type ?u.133900
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid N₁
inst✝⁵ : AddCommMonoid N₂
inst✝⁴ : AddCommMonoid N₃
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module S M₃
σ : R →+* S
fₗ gₗ : M →ₗ[R] M₂
f g : M →ₛₗ[σ] M₃
σ' : S →+* R
inst✝ : RingHomInvPair σ σ'
c : S
x : M
⊢ c • ↑f x = ↑f (↑σ' c • x)
Theorem: Nat.coprime_pow_right_iff
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Nat.coprime_comm, coprime_pow_left_iff hn, Nat.coprime_comm]
state_before: n : ℕ
hn : 0 < n
a b : ℕ
⊢ coprime a (b ^ n) ↔ coprime a b
Theorem: Finset.prod_update_of_mem
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [update_eq_piecewise, prod_piecewise]
state_before: ι : Type ?u.791147
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ ∏ x in s, Function.update f i b x = b * ∏ x in s \ {i}, f x

tactic: simp [h]
state_before: ι : Type ?u.791147
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ (∏ x in s ∩ {i}, b) * ∏ x in s \ {i}, f x = b * ∏ x in s \ {i}, f x
Theorem: EMetric.exists_real_pos_lt_infEdist_of_not_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [← infEdist_pos_iff_not_mem_closure, ENNReal.lt_iff_exists_real_btwn] at h
state_before: ι : Sort ?u.18420
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
h : ¬x ∈ closure E
⊢ ∃ ε, 0 < ε ∧ ENNReal.ofReal ε < infEdist x E

tactic: rcases h with ⟨ε, ⟨_, ⟨ε_pos, ε_lt⟩⟩⟩
state_before: ι : Sort ?u.18420
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
h : ∃ r, 0 ≤ r ∧ 0 < ENNReal.ofReal r ∧ ENNReal.ofReal r < infEdist x E
⊢ ∃ ε, 0 < ε ∧ ENNReal.ofReal ε < infEdist x E

tactic: exact ⟨ε, ⟨ENNReal.ofReal_pos.mp ε_pos, ε_lt⟩⟩
state_before: case intro.intro.intro
ι : Sort ?u.18420
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
ε : ℝ
left✝ : 0 ≤ ε
ε_pos : 0 < ENNReal.ofReal ε
ε_lt : ENNReal.ofReal ε < infEdist x E
⊢ ∃ ε, 0 < ε ∧ ENNReal.ofReal ε < infEdist x E
Theorem: Int.lt_add_of_neg_add_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_left h b
state_before: a b c : Int
h : -b + a < c
⊢ a < b + c

tactic: rwa [Int.add_neg_cancel_left] at h
state_before: a b c : Int
h✝ : -b + a < c
h : b + (-b + a) < b + c
⊢ a < b + c
Theorem: sup_right_idem
File: Mathlib/Order/Lattice.lean

tactic: simp
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ⊔ b ⊔ b = a ⊔ b
Theorem: Real.cos_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [two_mul, cos_add]
state_before: ⊢ cos (2 * π) = 1
Theorem: Function.IsPeriodicPt.mul_const
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp only [IsPeriodicPt, iterate_mul, hm.isFixedPt.iterate n]
state_before: α : Type u_1
β : Type ?u.2141
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hm : IsPeriodicPt f m x
n : ℕ
⊢ IsPeriodicPt f (m * n) x
Theorem: Polynomial.multiplicity_X_sub_C_finite
File: Mathlib/Data/Polynomial/Div.lean

tactic: haveI := Nontrivial.of_polynomial_ne h0
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
h0 : p ≠ 0
⊢ multiplicity.Finite (X - ↑C a) p

tactic: refine' multiplicity_finite_of_degree_pos_of_monic _ (monic_X_sub_C _) h0
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
h0 : p ≠ 0
this : Nontrivial R
⊢ multiplicity.Finite (X - ↑C a) p

tactic: rw [degree_X_sub_C]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
h0 : p ≠ 0
this : Nontrivial R
⊢ 0 < degree (X - ↑C a)

tactic: decide
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
a : R
h0 : p ≠ 0
this : Nontrivial R
⊢ 0 < 1
Theorem: Finset.sup_eq_sSup_image
File: Mathlib/Data/Finset/Lattice.lean

tactic: classical rw [← Finset.coe_image, ← sup_id_eq_sSup, sup_image, Function.comp.left_id]
state_before: F : Type ?u.92388
α : Type u_2
β : Type u_1
γ : Type ?u.92397
ι : Type ?u.92400
κ : Type ?u.92403
inst✝ : CompleteLattice β
s : Finset α
f : α → β
⊢ sup s f = sSup (f '' ↑s)

tactic: rw [← Finset.coe_image, ← sup_id_eq_sSup, sup_image, Function.comp.left_id]
state_before: F : Type ?u.92388
α : Type u_2
β : Type u_1
γ : Type ?u.92397
ι : Type ?u.92400
κ : Type ?u.92403
inst✝ : CompleteLattice β
s : Finset α
f : α → β
⊢ sup s f = sSup (f '' ↑s)
Theorem: inv_smul_lt_iff
File: Mathlib/Algebra/Order/SMul.lean

tactic: rw [← smul_lt_smul_iff_of_pos h, smul_inv_smul₀ h.ne']
state_before: ι : Type ?u.109399
𝕜 : Type u_1
R : Type ?u.109405
M : Type u_2
N : Type ?u.109411
inst✝⁵ : LinearOrderedSemifield 𝕜
inst✝⁴ : OrderedAddCommMonoid M
inst✝³ : OrderedAddCommMonoid N
inst✝² : MulActionWithZero 𝕜 M
inst✝¹ : MulActionWithZero 𝕜 N
inst✝ : OrderedSMul 𝕜 M
s : Set M
a b : M
c : 𝕜
h : 0 < c
⊢ c⁻¹ • a < b ↔ a < c • b
Theorem: IsOpenMap.id
File: Mathlib/Topology/Maps.lean

tactic: rwa [image_id]
state_before: α : Type u_1
β : Type ?u.139216
γ : Type ?u.139219
δ : Type ?u.139222
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
s : Set α
hs : IsOpen s
⊢ IsOpen (id '' s)
Theorem: PartENat.add_one_le_iff_lt
File: Mathlib/Data/Nat/PartENat.lean

tactic: refine ⟨fun h => ?_, add_one_le_of_lt⟩
state_before: x y : PartENat
hx : x ≠ ⊤
⊢ x + 1 ≤ y ↔ x < y

tactic: rcases ne_top_iff.mp hx with ⟨m, rfl⟩
state_before: x y : PartENat
hx : x ≠ ⊤
h : x + 1 ≤ y
⊢ x < y

tactic: induction' y using PartENat.casesOn with n
state_before: case intro
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h : ↑m + 1 ≤ y
⊢ ↑m < y

tactic: norm_cast
state_before: case intro.a
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h✝ : ↑m + 1 ≤ y
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ ↑m < ↑n

tactic: apply Nat.lt_of_succ_le
state_before: case intro.a
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h✝ : ↑m + 1 ≤ y
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ m < n

tactic: norm_cast at h
state_before: case intro.a.h
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h✝ : ↑m + 1 ≤ y
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ Nat.succ m ≤ n

tactic: apply natCast_lt_top
state_before: case intro.a
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h✝ : ↑m + 1 ≤ y
h : ↑m + 1 ≤ ⊤
⊢ ↑m < ⊤
Theorem: CategoryTheory.MorphismProperty.injective_stableUnderComposition
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: delta MorphismProperty.injective
state_before: C : Type u
inst✝² : Category C
D : Type ?u.89168
inst✝¹ : Category D
inst✝ : ConcreteCategory C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.injective C f
hg : MorphismProperty.injective C g
⊢ MorphismProperty.injective C (f ≫ g)

tactic: rw [coe_comp]
state_before: C : Type u
inst✝² : Category C
D : Type ?u.89168
inst✝¹ : Category D
inst✝ : ConcreteCategory C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.injective C f
hg : MorphismProperty.injective C g
⊢ Injective ((forget C).map (f ≫ g))

tactic: exact hg.comp hf
state_before: C : Type u
inst✝² : Category C
D : Type ?u.89168
inst✝¹ : Category D
inst✝ : ConcreteCategory C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.injective C f
hg : MorphismProperty.injective C g
⊢ Injective ((forget C).map g ∘ (forget C).map f)
Theorem: List.bagInter_nil_iff_inter_nil
File: Mathlib/Data/List/Lattice.lean

tactic: simp
state_before: α : Type u_1
l l₁ l₂✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₂ : List α
⊢ List.bagInter [] l₂ = [] ↔ [] ∩ l₂ = []

tactic: by_cases h : b ∈ l₂ <;> simp [h]
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
b : α
l₁ l₂ : List α
⊢ List.bagInter (b :: l₁) l₂ = [] ↔ (b :: l₁) ∩ l₂ = []

tactic: exact bagInter_nil_iff_inter_nil l₁ l₂
state_before: case neg
α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
b : α
l₁ l₂ : List α
h : ¬b ∈ l₂
⊢ List.bagInter l₁ l₂ = [] ↔ l₁ ∩ l₂ = []
Theorem: Subgroup.pi_eq_bot_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp only [eq_bot_iff_forall]
state_before: G : Type ?u.330176
G' : Type ?u.330179
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.330188
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.330209
inst✝² : Group N
P : Type ?u.330215
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
⊢ pi univ H = ⊥ ↔ ∀ (i : η), H i = ⊥

tactic: constructor
state_before: G : Type ?u.330176
G' : Type ?u.330179
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.330188
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.330209
inst✝² : Group N
P : Type ?u.330215
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
⊢ (∀ (x : (i : η) → f i), x ∈ pi univ H → x = 1) ↔ ∀ (i : η) (x : f i), x ∈ H i → x = 1

tactic: intro h i x hx
state_before: case mp
G : Type ?u.330176
G' : Type ?u.330179
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.330188
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.330209
inst✝² : Group N
P : Type ?u.330215
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
⊢ (∀ (x : (i : η) → f i), x ∈ pi univ H → x = 1) → ∀ (i : η) (x : f i), x ∈ H i → x = 1

tactic: have : MonoidHom.single f i x = 1 :=
  h (MonoidHom.single f i x) ((mulSingle_mem_pi i x).mpr fun _ => hx)
state_before: case mp
G : Type ?u.330176
G' : Type ?u.330179
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.330188
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.330209
inst✝² : Group N
P : Type ?u.330215
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
h : ∀ (x : (i : η) → f i), x ∈ pi univ H → x = 1
i : η
x : f i
hx : x ∈ H i
⊢ x = 1

tactic: simpa using congr_fun this i
state_before: case mp
G : Type ?u.330176
G' : Type ?u.330179
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.330188
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.330209
inst✝² : Group N
P : Type ?u.330215
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
h : ∀ (x : (i : η) → f i), x ∈ pi univ H → x = 1
i : η
x : f i
hx : x ∈ H i
this : ↑(MonoidHom.single f i) x = 1
⊢ x = 1

tactic: exact fun h x hx => funext fun i => h _ _ (hx i trivial)
state_before: case mpr
G : Type ?u.330176
G' : Type ?u.330179
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.330188
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.330209
inst✝² : Group N
P : Type ?u.330215
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
⊢ (∀ (i : η) (x : f i), x ∈ H i → x = 1) → ∀ (x : (i : η) → f i), x ∈ pi univ H → x = 1
Theorem: primitiveRoots_zero
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [primitiveRoots, nthRoots_zero, Multiset.toFinset_zero, Finset.filter_empty]
state_before: M : Type ?u.1451860
N : Type ?u.1451863
G : Type ?u.1451866
R : Type u_1
S : Type ?u.1451872
F : Type ?u.1451875
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ primitiveRoots 0 R = ∅
Theorem: Polynomial.X_ne_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ ¬coeff X 1 = coeff 0 1
Theorem: Set.prod_image_seq_comm
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← prod_eq_seq, ← image_swap_prod, prod_eq_seq, image_seq, ← image_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.274965
ι : Sort ?u.274968
ι' : Sort ?u.274971
ι₂ : Sort ?u.274974
κ : ι → Sort ?u.274979
κ₁ : ι → Sort ?u.274984
κ₂ : ι → Sort ?u.274989
κ' : ι' → Sort ?u.274994
s : Set α
t : Set β
⊢ seq (Prod.mk '' s) t = seq ((fun b a => (a, b)) '' t) s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.274965
ι : Sort ?u.274968
ι' : Sort ?u.274971
ι₂ : Sort ?u.274974
κ : ι → Sort ?u.274979
κ₁ : ι → Sort ?u.274984
κ₂ : ι → Sort ?u.274989
κ' : ι' → Sort ?u.274994
s : Set α
t : Set β
⊢ seq ((fun x x_1 => x ∘ x_1) Prod.swap ∘ Prod.mk '' t) s = seq ((fun b a => (a, b)) '' t) s
Theorem: Real.sinh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sinh]
state_before: x y : ℝ
⊢ sinh 0 = 0
Theorem: ModularGroup.coe_T_inv
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simp [coe_inv, coe_T, adjugate_fin_two]
state_before: ⊢ ↑T⁻¹ = ↑of ![![1, -1], ![0, 1]]
Theorem: List.kunion_nil
File: Mathlib/Data/List/Sigma.lean

tactic: rw [kunion, kerase_nil, kunion_nil]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
head✝ : Sigma β
l : List (Sigma β)
⊢ kunion (head✝ :: l) [] = head✝ :: l
Theorem: Con.ext'
File: Mathlib/GroupTheory/Congruence.lean

tactic: rcases c with ⟨⟨⟩⟩
state_before: M : Type u_1
N : Type ?u.6337
P : Type ?u.6340
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
H : r = r
⊢ c = d

tactic: rcases d with ⟨⟨⟩⟩
state_before: case mk.mk
M : Type u_1
N : Type ?u.6337
P : Type ?u.6340
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c d : Con M
r✝ : M → M → Prop
iseqv✝ : Equivalence r✝
mul'✝ : ∀ {w x y z : M}, r w x → r y z → r (w * y) (x * z)
H : r = r
⊢ { toSetoid := { r := r✝, iseqv := iseqv✝ }, mul' := mul'✝ } = d

tactic: cases H
state_before: case mk.mk.mk.mk
M : Type u_1
N : Type ?u.6337
P : Type ?u.6340
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r✝¹ : M → M → Prop
iseqv✝¹ : Equivalence r✝¹
mul'✝¹ : ∀ {w x y z : M}, r w x → r y z → r (w * y) (x * z)
r✝ : M → M → Prop
iseqv✝ : Equivalence r✝
mul'✝ : ∀ {w x y z : M}, r w x → r y z → r (w * y) (x * z)
H : r = r
⊢ { toSetoid := { r := r✝¹, iseqv := iseqv✝¹ }, mul' := mul'✝¹ } =
    { toSetoid := { r := r✝, iseqv := iseqv✝ }, mul' := mul'✝ }

tactic: congr
state_before: case mk.mk.mk.mk.refl
M : Type u_1
N : Type ?u.6337
P : Type ?u.6340
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
r✝ : M → M → Prop
iseqv✝¹ : Equivalence r✝
mul'✝¹ : ∀ {w x y z : M}, r w x → r y z → r (w * y) (x * z)
iseqv✝ : Equivalence r✝
mul'✝ : ∀ {w x y z : M}, r w x → r y z → r (w * y) (x * z)
⊢ { toSetoid := { r := r✝, iseqv := iseqv✝¹ }, mul' := mul'✝¹ } =
    { toSetoid := { r := r✝, iseqv := iseqv✝ }, mul' := mul'✝ }
Theorem: List.mem_union
File: Mathlib/Data/List/Lattice.lean

tactic: induction l₁
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
⊢ a ∈ l₁ ∪ l₂ ↔ a ∈ l₁ ∨ a ∈ l₂

tactic: simp only [not_mem_nil, false_or_iff, instUnionList, nil_union]
state_before: case nil
α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
⊢ a ∈ [] ∪ l₂ ↔ a ∈ [] ∨ a ∈ l₂

tactic: simp only [find?, mem_cons, or_assoc, instUnionList, cons_union, mem_union_iff, mem_insert_iff]
state_before: case cons
α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
head✝ : α
tail✝ : List α
tail_ih✝ : a ∈ tail✝ ∪ l₂ ↔ a ∈ tail✝ ∨ a ∈ l₂
⊢ a ∈ head✝ :: tail✝ ∪ l₂ ↔ a ∈ head✝ :: tail✝ ∨ a ∈ l₂
Theorem: AlternatingMap.measure_parallelepiped
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: conv_rhs => rw [ω.eq_smul_basis_det (finBasisOfFinrankEq ℝ G _i.out)]
state_before: E : Type ?u.2090966
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace ℝ E
inst✝¹³ : MeasurableSpace E
inst✝¹² : BorelSpace E
inst✝¹¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝¹⁰ : IsAddHaarMeasure μ
F : Type ?u.2091635
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace ℝ F
inst✝⁷ : CompleteSpace F
s : Set E
ι : Type ?u.2091829
G : Type u_1
inst✝⁶ : Fintype ι
inst✝⁵ : DecidableEq ι
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
inst✝² : MeasurableSpace G
inst✝¹ : BorelSpace G
inst✝ : FiniteDimensional ℝ G
n : ℕ
_i : Fact (finrank ℝ G = n)
ω : AlternatingMap ℝ G ℝ (Fin n)
v : Fin n → G
⊢ ↑↑(AlternatingMap.measure ω) (parallelepiped v) = ENNReal.ofReal (abs (↑ω v))

tactic: simp only [addHaar_parallelepiped, AlternatingMap.measure, coe_nnreal_smul_apply,
  AlternatingMap.smul_apply, Algebra.id.smul_eq_mul, abs_mul, ENNReal.ofReal_mul (abs_nonneg _),
  Real.ennnorm_eq_ofReal_abs]
state_before: E : Type ?u.2090966
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace ℝ E
inst✝¹³ : MeasurableSpace E
inst✝¹² : BorelSpace E
inst✝¹¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝¹⁰ : IsAddHaarMeasure μ
F : Type ?u.2091635
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace ℝ F
inst✝⁷ : CompleteSpace F
s : Set E
ι : Type ?u.2091829
G : Type u_1
inst✝⁶ : Fintype ι
inst✝⁵ : DecidableEq ι
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
inst✝² : MeasurableSpace G
inst✝¹ : BorelSpace G
inst✝ : FiniteDimensional ℝ G
n : ℕ
_i : Fact (finrank ℝ G = n)
ω : AlternatingMap ℝ G ℝ (Fin n)
v : Fin n → G
⊢ ↑↑(AlternatingMap.measure ω) (parallelepiped v) =
    ENNReal.ofReal
      (abs
        (↑(↑ω ↑(finBasisOfFinrankEq ℝ G (_ : finrank ℝ G = n)) •
              Basis.det (finBasisOfFinrankEq ℝ G (_ : finrank ℝ G = n)))
          v))