tasksource/leandojo huggingface dataset:
Theorem: LipschitzOnWith.of_le_add
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [NNReal.coe_one, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
s : Set α
f✝ : α → β
f : α → ℝ
h : ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → f x ≤ f y + dist x y
⊢ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → f x ≤ f y + ↑1 * dist x y
Theorem: Complex.frontier_setOf_lt_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [frontier_Ioi] using frontier_preimage_re (Ioi a)
state_before: a : ℝ
⊢ frontier {z | a < z.re} = {z | z.re = a}
Theorem: CategoryTheory.imageToKernel_isIso_of_image_eq_kernel
File: Mathlib/Algebra/Homology/Exact.lean

tactic: refine' ⟨⟨Subobject.ofLE _ _ p.ge, _⟩⟩
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ IsIso (imageToKernel f g (_ : f ≫ g = 0))

tactic: dsimp [imageToKernel]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ imageToKernel f g (_ : f ≫ g = 0) ≫
        Subobject.ofLE (kernelSubobject g) (imageSubobject f) (_ : kernelSubobject g ≤ imageSubobject f) =
      𝟙 (Subobject.underlying.obj (imageSubobject f)) ∧
    Subobject.ofLE (kernelSubobject g) (imageSubobject f) (_ : kernelSubobject g ≤ imageSubobject f) ≫
        imageToKernel f g (_ : f ≫ g = 0) =
      𝟙 (Subobject.underlying.obj (kernelSubobject g))

tactic: simp only [Subobject.ofLE_comp_ofLE, Subobject.ofLE_refl]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ Subobject.ofLE (imageSubobject f) (kernelSubobject g) (_ : imageSubobject f ≤ kernelSubobject g) ≫
        Subobject.ofLE (kernelSubobject g) (imageSubobject f) (_ : kernelSubobject g ≤ imageSubobject f) =
      𝟙 (Subobject.underlying.obj (imageSubobject f)) ∧
    Subobject.ofLE (kernelSubobject g) (imageSubobject f) (_ : kernelSubobject g ≤ imageSubobject f) ≫
        Subobject.ofLE (imageSubobject f) (kernelSubobject g) (_ : imageSubobject f ≤ kernelSubobject g) =
      𝟙 (Subobject.underlying.obj (kernelSubobject g))
Theorem: LieSubalgebra.ad_comp_incl_eq
File: Mathlib/Algebra/Lie/OfAssociative.lean

tactic: ext y
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
x : { x // x ∈ K }
⊢ LinearMap.comp (↑(ad R L) ↑x) ↑(incl K) = LinearMap.comp (↑(incl K)) (↑(ad R { x // x ∈ K }) x)

tactic: simp only [ad_apply, LieHom.coe_toLinearMap, LieSubalgebra.coe_incl, LinearMap.coe_comp,
  LieSubalgebra.coe_bracket, Function.comp_apply]
state_before: case h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K : LieSubalgebra R L
x y : { x // x ∈ K }
⊢ ↑(LinearMap.comp (↑(ad R L) ↑x) ↑(incl K)) y = ↑(LinearMap.comp (↑(incl K)) (↑(ad R { x // x ∈ K }) x)) y
Theorem: SimpleGraph.deleteEdges_eq_sdiff_fromEdgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext
state_before: ι : Sort ?u.154730
𝕜 : Type ?u.154733
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ deleteEdges G s = G \ fromEdgeSet s

tactic: exact ⟨fun h => ⟨h.1, not_and_of_not_left _ h.2⟩, fun h => ⟨h.1, not_and'.mp h.2 h.ne⟩⟩
state_before: case Adj.h.h.a
ι : Sort ?u.154730
𝕜 : Type ?u.154733
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
x✝¹ x✝ : V
⊢ Adj (deleteEdges G s) x✝¹ x✝ ↔ Adj (G \ fromEdgeSet s) x✝¹ x✝
Theorem: IsometryEquiv.preimage_emetric_ball
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.isometry.preimage_emetric_ball (h.symm x) r, h.apply_symm_apply]
state_before: ι : Type ?u.652149
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
x : β
r : ℝ≥0∞
⊢ ↑h ⁻¹' EMetric.ball x r = EMetric.ball (↑(IsometryEquiv.symm h) x) r
Theorem: Sum.isPreconnected_iff
File: Mathlib/Topology/Connected.lean

tactic: refine' ⟨fun hs => _, _⟩
state_before: α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
⊢ IsPreconnected s ↔ (∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t

tactic: obtain rfl | h := s.eq_empty_or_nonempty
state_before: case refine'_1
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
hs : IsPreconnected s
⊢ (∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t

tactic: obtain ⟨t, ht, rfl⟩ | ⟨t, ht, rfl⟩ := Sum.isConnected_iff.1 ⟨h, hs⟩
state_before: case refine'_1.inr
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
hs : IsPreconnected s
h : Set.Nonempty s
⊢ (∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t

tactic: exact Or.inl ⟨∅, isPreconnected_empty, (Set.image_empty _).symm⟩
state_before: case refine'_1.inl
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : TopologicalSpace β
hs : IsPreconnected ∅
⊢ (∃ t, IsPreconnected t ∧ ∅ = inl '' t) ∨ ∃ t, IsPreconnected t ∧ ∅ = inr '' t

tactic: exact Or.inl ⟨t, ht.isPreconnected, rfl⟩
state_before: case refine'_1.inr.inl.intro.intro
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s t✝ u v : Set α
inst✝ : TopologicalSpace β
t : Set α
ht : IsConnected t
hs : IsPreconnected (inl '' t)
h : Set.Nonempty (inl '' t)
⊢ (∃ t_1, IsPreconnected t_1 ∧ inl '' t = inl '' t_1) ∨ ∃ t_1, IsPreconnected t_1 ∧ inl '' t = inr '' t_1

tactic: exact Or.inr ⟨t, ht.isPreconnected, rfl⟩
state_before: case refine'_1.inr.inr.intro.intro
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s t✝ u v : Set α
inst✝ : TopologicalSpace β
t : Set β
ht : IsConnected t
hs : IsPreconnected (inr '' t)
h : Set.Nonempty (inr '' t)
⊢ (∃ t_1, IsPreconnected t_1 ∧ inr '' t = inl '' t_1) ∨ ∃ t_1, IsPreconnected t_1 ∧ inr '' t = inr '' t_1

tactic: rintro (⟨t, ht, rfl⟩ | ⟨t, ht, rfl⟩)
state_before: case refine'_2
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
⊢ ((∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t) → IsPreconnected s

tactic: exact ht.image _ continuous_inl.continuousOn
state_before: case refine'_2.inl.intro.intro
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s t✝ u v : Set α
inst✝ : TopologicalSpace β
t : Set α
ht : IsPreconnected t
⊢ IsPreconnected (inl '' t)

tactic: exact ht.image _ continuous_inr.continuousOn
state_before: case refine'_2.inr.intro.intro
α : Type u
β : Type v
ι : Type ?u.44185
π : ι → Type ?u.44190
inst✝¹ : TopologicalSpace α
s t✝ u v : Set α
inst✝ : TopologicalSpace β
t : Set β
ht : IsPreconnected t
⊢ IsPreconnected (inr '' t)
Theorem: Set.range_list_nthLe
File: Mathlib/Data/Set/List.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.905
l : List α
⊢ (range fun k => nthLe l ↑k (_ : ↑k < length l)) = {x | x ∈ l}

tactic: rw [mem_setOf_eq, mem_iff_get]
state_before: case h
α : Type u_1
β : Type ?u.905
l : List α
x : α
⊢ (x ∈ range fun k => nthLe l ↑k (_ : ↑k < length l)) ↔ x ∈ {x | x ∈ l}

tactic: exact ⟨fun ⟨⟨n, h₁⟩, h₂⟩ => ⟨⟨n, h₁⟩, h₂⟩, fun ⟨⟨n, h₁⟩, h₂⟩ => ⟨⟨n, h₁⟩, h₂⟩⟩
state_before: case h
α : Type u_1
β : Type ?u.905
l : List α
x : α
⊢ (x ∈ range fun k => nthLe l ↑k (_ : ↑k < length l)) ↔ ∃ n, List.get l n = x
Theorem: PSet.toSet_sUnion
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: x : PSet
⊢ toSet (⋃₀ x) = ⋃₀ (toSet '' toSet x)

tactic: simp
state_before: case h
x x✝ : PSet
⊢ x✝ ∈ toSet (⋃₀ x) ↔ x✝ ∈ ⋃₀ (toSet '' toSet x)
Theorem: matPolyEquiv_symm_apply_coeff
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: have t : p = matPolyEquiv (matPolyEquiv.symm p) := by simp
state_before: R : Type u_1
A : Type ?u.570514
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
⊢ coeff (↑(AlgEquiv.symm matPolyEquiv) p i j) k = coeff p k i j

tactic: conv_rhs => rw [t]
state_before: R : Type u_1
A : Type ?u.570514
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
t : p = ↑matPolyEquiv (↑(AlgEquiv.symm matPolyEquiv) p)
⊢ coeff (↑(AlgEquiv.symm matPolyEquiv) p i j) k = coeff p k i j

tactic: simp only [matPolyEquiv_coeff_apply]
state_before: R : Type u_1
A : Type ?u.570514
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
t : p = ↑matPolyEquiv (↑(AlgEquiv.symm matPolyEquiv) p)
⊢ coeff (↑(AlgEquiv.symm matPolyEquiv) p i j) k = coeff (↑matPolyEquiv (↑(AlgEquiv.symm matPolyEquiv) p)) k i j

tactic: simp
state_before: R : Type u_1
A : Type ?u.570514
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : (Matrix n n R)[X]
i j : n
k : ℕ
⊢ p = ↑matPolyEquiv (↑(AlgEquiv.symm matPolyEquiv) p)
Theorem: zpow_bit0_pos_iff
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: rintro h rfl
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hn : n ≠ 0
⊢ 0 < a ^ bit0 n → a ≠ 0

tactic: refine' (zero_zpow _ _).not_gt h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
hn : n ≠ 0
h : 0 < 0 ^ bit0 n
⊢ False

tactic: rwa [bit0_ne_zero]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
hn : n ≠ 0
h : 0 < 0 ^ bit0 n
⊢ bit0 n ≠ 0
Theorem: CategoryTheory.Limits.biproduct.ι_toSubtype_subtype
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: apply biproduct.hom_ext
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j : Subtype p
⊢ ι f ↑j ≫ toSubtype f p = ι (Subtype.restrict p f) j

tactic: intro i
state_before: case w
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j : Subtype p
⊢ ∀ (j_1 : Subtype p),
    (ι f ↑j ≫ toSubtype f p) ≫ π (Subtype.restrict p f) j_1 = ι (Subtype.restrict p f) j ≫ π (Subtype.restrict p f) j_1

tactic: rw [biproduct.toSubtype, Category.assoc, biproduct.lift_π, biproduct.ι_π, biproduct.ι_π]
state_before: case w
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j i : Subtype p
⊢ (ι f ↑j ≫ toSubtype f p) ≫ π (Subtype.restrict p f) i = ι (Subtype.restrict p f) j ≫ π (Subtype.restrict p f) i

tactic: split_ifs with h₁ h₂ h₂
state_before: case w
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j i : Subtype p
⊢ (if h : ↑j = ↑i then eqToHom (_ : f ↑j = f ↑i) else 0) =
    if h : j = i then eqToHom (_ : Subtype.restrict p f j = Subtype.restrict p f i) else 0

tactic: exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl]
state_before: case w.inl.inl
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j i : Subtype p
h₁ : ↑j = ↑i
h₂ : j = i
⊢ eqToHom (_ : f ↑j = f ↑i) = eqToHom (_ : Subtype.restrict p f j = Subtype.restrict p f i)

case w.inl.inr
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j i : Subtype p
h₁ : ↑j = ↑i
h₂ : ¬j = i
⊢ eqToHom (_ : f ↑j = f ↑i) = 0

case w.inr.inl
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j i : Subtype p
h₁ : ¬↑j = ↑i
h₂ : j = i
⊢ 0 = eqToHom (_ : Subtype.restrict p f j = Subtype.restrict p f i)

case w.inr.inr
J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f : J → C
inst✝¹ : HasBiproduct f
p : J → Prop
inst✝ : HasBiproduct (Subtype.restrict p f)
j i : Subtype p
h₁ : ¬↑j = ↑i
h₂ : ¬j = i
⊢ 0 = 0
Theorem: FirstOrder.Language.relMap_leSymb
File: Mathlib/ModelTheory/Order.lean

tactic: rw [← orderLHom_leSymb, LHom.map_onRelation]
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝³ : IsOrdered L
inst✝² : Structure L M
inst✝¹ : LE M
inst✝ : OrderedStructure L M
a b : M
⊢ RelMap leSymb ![a, b] ↔ a ≤ b

tactic: rfl
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝³ : IsOrdered L
inst✝² : Structure L M
inst✝¹ : LE M
inst✝ : OrderedStructure L M
a b : M
⊢ RelMap leSymb ![a, b] ↔ a ≤ b
Theorem: Multiset.length_toList
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← coe_card, coe_toList]
state_before: α : Type u_1
β : Type ?u.51217
γ : Type ?u.51220
s : Multiset α
⊢ length (toList s) = ↑card s
Theorem: CategoryTheory.Preadditive.neg_comp_neg
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
P Q R : C
f f' : P ⟶ Q
g g' : Q ⟶ R
⊢ (-f) ≫ (-g) = f ≫ g
Theorem: Finset.prod_range_reflect
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: cases n
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ j in range n, f (n - 1 - j) = ∏ j in range n, f j

tactic: simp
state_before: case zero
α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
⊢ ∏ j in range zero, f (zero - 1 - j) = ∏ j in range zero, f j

tactic: simp only [← Nat.Ico_zero_eq_range, Nat.succ_sub_succ_eq_sub, tsub_zero]
state_before: case succ
α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
n✝ : ℕ
⊢ ∏ j in range (succ n✝), f (succ n✝ - 1 - j) = ∏ j in range (succ n✝), f j

tactic: rw [prod_Ico_reflect _ _ le_rfl]
state_before: case succ
α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
n✝ : ℕ
⊢ ∏ x in Ico 0 (succ n✝), f (n✝ - x) = ∏ x in Ico 0 (succ n✝), f x

tactic: simp
state_before: case succ
α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
n✝ : ℕ
⊢ ∏ j in Ico (n✝ + 1 - (n✝ + 1)) (n✝ + 1 - 0), f j = ∏ x in Ico 0 (succ n✝), f x
Theorem: Int.le_mul_of_ediv_le
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [← Int.ediv_mul_cancel H2]
state_before: a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
H1 : 0 ≤ b
H2 : b ∣ a
H3 : a / b ≤ c
⊢ a ≤ c * b

tactic: exact mul_le_mul_of_nonneg_right H3 H1
state_before: a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
H1 : 0 ≤ b
H2 : b ∣ a
H3 : a / b ≤ c
⊢ a / b * b ≤ c * b
Theorem: Submonoid.prod_eq_top_iff
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp only [eq_top_iff, le_prod_iff, ← (gc_map_comap _).le_iff_le, ← mrange_eq_map, mrange_fst,
  mrange_snd]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.155993
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.156014
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
⊢ prod s t = ⊤ ↔ s = ⊤ ∧ t = ⊤
Theorem: mul_le_mul_left₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: simp only [mul_comm a]
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
ha : a ≠ 0
⊢ a * b ≤ a * c ↔ b ≤ c

tactic: exact mul_le_mul_right₀ ha
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
ha : a ≠ 0
⊢ b * a ≤ c * a ↔ b ≤ c
Theorem: Finset.swap_mem_mulAntidiagonal
File: Mathlib/Data/Finset/MulAntidiagonal.lean

tactic: simp only [mem_mulAntidiagonal, Prod.fst_swap, Prod.snd_swap, Set.swap_mem_mulAntidiagonal_aux,
           Set.mem_mulAntidiagonal]
state_before: α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
hs : Set.IsPwo s
ht : Set.IsPwo t
a : α
u : Set α
hu : Set.IsPwo u
x : α × α
⊢ Prod.swap x ∈ mulAntidiagonal hs ht a ↔ x ∈ mulAntidiagonal ht hs a
Theorem: Ordinal.enum_zero_le'
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rwa [type_lt]
state_before: α : Type ?u.194863
β : Type ?u.194866
γ : Type ?u.194869
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h0 : 0 < o
a : (Quotient.out o).α
⊢ 0 < type fun x x_1 => x < x_1

tactic: rw [← not_lt]
state_before: α : Type ?u.194863
β : Type ?u.194866
γ : Type ?u.194869
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h0 : 0 < o
a : (Quotient.out o).α
⊢ enum (fun x x_1 => x < x_1) 0 (_ : 0 < type fun x x_1 => x < x_1) ≤ a

tactic: apply enum_zero_le
state_before: α : Type ?u.194863
β : Type ?u.194866
γ : Type ?u.194869
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h0 : 0 < o
a : (Quotient.out o).α
⊢ ¬a < enum (fun x x_1 => x < x_1) 0 (_ : 0 < type fun x x_1 => x < x_1)
Theorem: map_inv_lt_iff
File: Mathlib/Order/Hom/Basic.lean

tactic: rw [← map_lt_map_iff f]
state_before: F : Type u_2
α : Type u_1
β : Type u_3
γ : Type ?u.32188
δ : Type ?u.32191
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ EquivLike.inv f b < a ↔ b < ↑f a

tactic: simp only [EquivLike.apply_inv_apply]
state_before: F : Type u_2
α : Type u_1
β : Type u_3
γ : Type ?u.32188
δ : Type ?u.32191
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ ↑f (EquivLike.inv f b) < ↑f a ↔ b < ↑f a
Theorem: Zsqrtd.smul_val
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [ext]
state_before: d n x y : ℤ
⊢ ↑n * { re := x, im := y } = { re := n * x, im := n * y }
Theorem: LinearMap.IsAdjointPair.add
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [f.add_apply, g.add_apply, B'.map_add₂, (B x).map_add, h, h']
state_before: R : Type u_1
R₁ : Type ?u.311393
R₂ : Type ?u.311396
R₃ : Type ?u.311399
M : Type u_2
M₁ : Type u_3
M₂ : Type ?u.311408
Mₗ₁ : Type ?u.311411
Mₗ₁' : Type ?u.311414
Mₗ₂ : Type ?u.311417
Mₗ₂' : Type ?u.311420
K : Type ?u.311423
K₁ : Type ?u.311426
K₂ : Type ?u.311429
V : Type ?u.311432
V₁ : Type ?u.311435
V₂ : Type ?u.311438
n : Type ?u.311441
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
I : R →+* R
B F : M →ₗ[R] M →ₛₗ[I] R
B' : M₁ →ₗ[R] M₁ →ₛₗ[I] R
B'' : M₂ →ₗ[R] M₂ →ₛₗ[I] R
f f' : M →ₗ[R] M₁
g g' : M₁ →ₗ[R] M
h : IsAdjointPair B B' f g
h' : IsAdjointPair B B' f' g'
x : M
x✝ : M₁
⊢ ↑(↑B' (↑(f + f') x)) x✝ = ↑(↑B x) (↑(g + g') x✝)
Theorem: MulLECancellable.mul_le_iff_le_one_right
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type ?u.87676
inst✝² : LE α
inst✝¹ : MulOneClass α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a * b ≤ a ↔ a * b ≤ a * 1
Theorem: Polynomial.leadingCoeff_add_of_degree_eq
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: have : natDegree (p + q) = natDegree p := by
  apply natDegree_eq_of_degree_eq;
    rw [degree_add_eq_of_leadingCoeff_add_ne_zero hlc, h, max_self]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.652536
h : degree p = degree q
hlc : leadingCoeff p + leadingCoeff q ≠ 0
⊢ leadingCoeff (p + q) = leadingCoeff p + leadingCoeff q

tactic: simp only [leadingCoeff, this, natDegree_eq_of_degree_eq h, coeff_add]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.652536
h : degree p = degree q
hlc : leadingCoeff p + leadingCoeff q ≠ 0
this : natDegree (p + q) = natDegree p
⊢ leadingCoeff (p + q) = leadingCoeff p + leadingCoeff q

tactic: apply natDegree_eq_of_degree_eq
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.652536
h : degree p = degree q
hlc : leadingCoeff p + leadingCoeff q ≠ 0
⊢ natDegree (p + q) = natDegree p

tactic: rw [degree_add_eq_of_leadingCoeff_add_ne_zero hlc, h, max_self]
state_before: case h
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.652536
h : degree p = degree q
hlc : leadingCoeff p + leadingCoeff q ≠ 0
⊢ degree (p + q) = degree p
Theorem: hasSum_cauchyPowerSeries_integral
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [cauchyPowerSeries_apply]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
w : ℂ
hf : CircleIntegrable f c R
hw : ↑Complex.abs w < R
⊢ HasSum (fun n => ↑(cauchyPowerSeries f c R n) fun x => w)
    ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - (c + w))⁻¹ • f z)

tactic: exact (hasSum_two_pi_I_cauchyPowerSeries_integral hf hw).const_smul _
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
w : ℂ
hf : CircleIntegrable f c R
hw : ↑Complex.abs w < R
⊢ HasSum (fun n => (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (w / (z - c)) ^ n • (z - c)⁻¹ • f z)
    ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - (c + w))⁻¹ • f z)
Theorem: Associates.finset_prod_mk
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: have : (fun i => Associates.mk (f i)) = Associates.mk ∘ f :=
  funext <| fun x => Function.comp_apply
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.34497
δ : Type ?u.34500
inst✝ : CommMonoid α
p : Finset β
f : β → α
⊢ ∏ i in p, Associates.mk (f i) = Associates.mk (∏ i in p, f i)

tactic: rw [Finset.prod_eq_multiset_prod, this, ←Multiset.map_map, prod_mk, ←Finset.prod_eq_multiset_prod]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.34497
δ : Type ?u.34500
inst✝ : CommMonoid α
p : Finset β
f : β → α
this : (fun i => Associates.mk (f i)) = Associates.mk ∘ f
⊢ ∏ i in p, Associates.mk (f i) = Associates.mk (∏ i in p, f i)
Theorem: Group.normalClosure_subset
File: Mathlib/Deprecated/Subgroup.lean

tactic: induction' w with x hx x _ ihx x y _ _ ihx ihy
state_before: G : Type u_1
H : Type ?u.145368
A : Type ?u.145371
a✝ a₁ a₂ b c : G
s✝ : Set G
inst✝ : Group G
s t : Set G
ht : IsNormalSubgroup t
h : s ⊆ t
a : G
w : a ∈ normalClosure s
⊢ a ∈ t

tactic: exact conjugatesOfSet_subset' ht h <| hx
state_before: case basic
G : Type u_1
H : Type ?u.145368
A : Type ?u.145371
a✝ a₁ a₂ b c : G
s✝ : Set G
inst✝ : Group G
s t : Set G
ht : IsNormalSubgroup t
h : s ⊆ t
a x : G
hx : x ∈ conjugatesOfSet s
⊢ x ∈ t

tactic: exact ht.toIsSubgroup.toIsSubmonoid.one_mem
state_before: case one
G : Type u_1
H : Type ?u.145368
A : Type ?u.145371
a✝ a₁ a₂ b c : G
s✝ : Set G
inst✝ : Group G
s t : Set G
ht : IsNormalSubgroup t
h : s ⊆ t
a : G
⊢ 1 ∈ t

tactic: exact ht.toIsSubgroup.inv_mem ihx
state_before: case inv
G : Type u_1
H : Type ?u.145368
A : Type ?u.145371
a✝¹ a₁ a₂ b c : G
s✝ : Set G
inst✝ : Group G
s t : Set G
ht : IsNormalSubgroup t
h : s ⊆ t
a x : G
a✝ : InClosure (conjugatesOfSet s) x
ihx : x ∈ t
⊢ x⁻¹ ∈ t

tactic: exact ht.toIsSubgroup.toIsSubmonoid.mul_mem ihx ihy
state_before: case mul
G : Type u_1
H : Type ?u.145368
A : Type ?u.145371
a✝² a₁ a₂ b c : G
s✝ : Set G
inst✝ : Group G
s t : Set G
ht : IsNormalSubgroup t
h : s ⊆ t
a x y : G
a✝¹ : InClosure (conjugatesOfSet s) x
a✝ : InClosure (conjugatesOfSet s) y
ihx : x ∈ t
ihy : y ∈ t
⊢ x * y ∈ t