tasksource/leandojo huggingface dataset:
Theorem: ContinuousMonoidHom.toContinuousMap_injective
File: Mathlib/Topology/Algebra/ContinuousMonoidHom.lean

tactic: convert FunLike.ext_iff.1 h
state_before: F : Type ?u.14417
A : Type u_1
B : Type u_2
C : Type ?u.14426
D : Type ?u.14429
E : Type ?u.14432
inst✝¹⁰ : Monoid A
inst✝⁹ : Monoid B
inst✝⁸ : Monoid C
inst✝⁷ : Monoid D
inst✝⁶ : CommGroup E
inst✝⁵ : TopologicalSpace A
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace C
inst✝² : TopologicalSpace D
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalGroup E
f g : ContinuousMonoidHom A B
h : toContinuousMap f = toContinuousMap g
⊢ ∀ (x : A), ↑f x = ↑g x
Theorem: Equiv.Perm.support_pow_coprime
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
n : ℕ
h : Nat.coprime n (orderOf σ)
⊢ support (σ ^ n) = support σ

tactic: exact
  le_antisymm (support_pow_le σ n)
    (le_trans (ge_of_eq (congr_arg support hm)) (support_pow_le (σ ^ n) m))
state_before: case intro
α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
n : ℕ
h : Nat.coprime n (orderOf σ)
m : ℕ
hm : (σ ^ n) ^ m = σ
⊢ support (σ ^ n) = support σ
Theorem: Finset.sizeOf_lt_sizeOf_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: cases s
state_before: α : Type u_1
β : Type ?u.287378
γ : Type ?u.287381
inst✝ : SizeOf α
x : α
s : Finset α
hx : x ∈ s
⊢ SizeOf.sizeOf x < SizeOf.sizeOf s

tactic: dsimp [SizeOf.sizeOf, SizeOf.sizeOf, Multiset.sizeOf]
state_before: case mk
α : Type u_1
β : Type ?u.287378
γ : Type ?u.287381
inst✝ : SizeOf α
x : α
val✝ : Multiset α
nodup✝ : Nodup val✝
hx : x ∈ { val := val✝, nodup := nodup✝ }
⊢ SizeOf.sizeOf x < SizeOf.sizeOf { val := val✝, nodup := nodup✝ }

tactic: rw [add_comm]
state_before: case mk
α : Type u_1
β : Type ?u.287378
γ : Type ?u.287381
inst✝ : SizeOf α
x : α
val✝ : Multiset α
nodup✝ : Nodup val✝
hx : x ∈ { val := val✝, nodup := nodup✝ }
⊢ SizeOf.sizeOf x <
    1 +
      Quot.liftOn val✝ (fun m => List._sizeOf_1 m)
        (_ : ∀ (x x_1 : List α), x ~ x_1 → SizeOf.sizeOf x = SizeOf.sizeOf x_1)

tactic: refine' lt_trans _ (Nat.lt_succ_self _)
state_before: case mk
α : Type u_1
β : Type ?u.287378
γ : Type ?u.287381
inst✝ : SizeOf α
x : α
val✝ : Multiset α
nodup✝ : Nodup val✝
hx : x ∈ { val := val✝, nodup := nodup✝ }
⊢ SizeOf.sizeOf x <
    Quot.liftOn val✝ (fun m => List._sizeOf_1 m)
        (_ : ∀ (x x_1 : List α), x ~ x_1 → SizeOf.sizeOf x = SizeOf.sizeOf x_1) +
      1

tactic: exact Multiset.sizeOf_lt_sizeOf_of_mem hx
state_before: case mk
α : Type u_1
β : Type ?u.287378
γ : Type ?u.287381
inst✝ : SizeOf α
x : α
val✝ : Multiset α
nodup✝ : Nodup val✝
hx : x ∈ { val := val✝, nodup := nodup✝ }
⊢ SizeOf.sizeOf x <
    Quot.liftOn val✝ (fun m => List._sizeOf_1 m) (_ : ∀ (x x_1 : List α), x ~ x_1 → SizeOf.sizeOf x = SizeOf.sizeOf x_1)
Theorem: continuousWithinAt_Icc_iff_Iic
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_Icc_eq_nhdsWithin_Iic h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
a✝ b✝ : α
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace β
a b : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Icc a b) b ↔ ContinuousWithinAt f (Iic b) b
Theorem: List.rel_mem
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [not_mem_nil]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132020
δ : Type ?u.132023
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
hr : BiUnique R
a : α
b : β
x✝ : R a b
⊢ (fun x x_1 => x ∈ x_1) a [] ↔ (fun x x_1 => x ∈ x_1) b []

tactic: simp only [mem_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132020
δ : Type ?u.132023
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
hr : BiUnique R
a : α
b : β
h : R a b
a' : α
as : List α
b' : β
bs : List β
h₁ : R a' b'
h₂ : Forall₂ R as bs
⊢ (fun x x_1 => x ∈ x_1) a (a' :: as) ↔ (fun x x_1 => x ∈ x_1) b (b' :: bs)

tactic: exact rel_or (rel_eq hr h h₁) (rel_mem hr h h₂)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132020
δ : Type ?u.132023
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
hr : BiUnique R
a : α
b : β
h : R a b
a' : α
as : List α
b' : β
bs : List β
h₁ : R a' b'
h₂ : Forall₂ R as bs
⊢ a = a' ∨ a ∈ as ↔ b = b' ∨ b ∈ bs
Theorem: Real.arcsin_eq_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw_mod_cast [arctan_eq_arcsin, div_pow, sq_sqrt, one_add_div, div_div, ← sqrt_mul,
  mul_div_cancel', sub_add_cancel, sqrt_one, div_one] <;> simp at h <;> nlinarith [h.1, h.2]
state_before: x : ℝ
h : x ∈ Ioo (-1) 1
⊢ arcsin x = arctan (x / sqrt (↑1 - x ^ 2))
Theorem: Polynomial.natDegree_le_of_dvd
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rcases h1 with ⟨q, rfl⟩
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h1 : p ∣ q
h2 : q ≠ 0
⊢ natDegree p ≤ natDegree q

tactic: rw [mul_ne_zero_iff] at h2
state_before: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p * q ≠ 0
⊢ natDegree p ≤ natDegree (p * q)

tactic: rw [natDegree_mul h2.1 h2.2]
state_before: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p ≠ 0 ∧ q ≠ 0
⊢ natDegree p ≤ natDegree (p * q)

tactic: exact Nat.le_add_right _ _
state_before: case intro
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h2 : p ≠ 0 ∧ q ≠ 0
⊢ natDegree p ≤ natDegree p + natDegree q
Theorem: add_sq
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: simp only [sq, add_mul_self_eq]
state_before: R : Type u_1
S : Type ?u.86348
M : Type ?u.86351
inst✝ : CommSemiring R
a b : R
⊢ (a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2
Theorem: Set.preimage_range_inter
File: Mathlib/Data/Set/Image.lean

tactic: rw [inter_comm, preimage_inter_range]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.77826
ι : Sort ?u.77829
ι' : Sort ?u.77832
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set β
⊢ f ⁻¹' (range f ∩ s) = f ⁻¹' s
Theorem: Std.RBNode.Stream.foldr_cons
File: Std/Data/RBMap/Lemmas.lean

tactic: unfold toList
state_before: α : Type u_1
t : RBNode.Stream α
l : List α
⊢ foldr (fun x x_1 => x :: x_1) t l = toList t ++ l

tactic: apply Eq.symm
state_before: α : Type u_1
t : RBNode.Stream α
l : List α
⊢ foldr (fun x x_1 => x :: x_1) t l = foldr (fun x x_1 => x :: x_1) t [] ++ l

tactic: induction t <;> simp [*, foldr, RBNode.foldr_cons]
state_before: case h
α : Type u_1
t : RBNode.Stream α
l : List α
⊢ foldr (fun x x_1 => x :: x_1) t [] ++ l = foldr (fun x x_1 => x :: x_1) t l
Theorem: Finset.coe_zpow
File: Mathlib/Data/Finset/Pointwise.lean

tactic: refine' (coe_inv _).trans _
state_before: F : Type ?u.506479
α : Type u_1
β : Type ?u.506485
γ : Type ?u.506488
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s✝ t s : Finset α
n : ℕ
⊢ ↑(s ^ Int.negSucc n) = ↑s ^ Int.negSucc n

tactic: exact congr_arg Inv.inv (coe_pow _ _)
state_before: F : Type ?u.506479
α : Type u_1
β : Type ?u.506485
γ : Type ?u.506488
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s✝ t s : Finset α
n : ℕ
⊢ (↑(npowRec (Nat.succ n) s))⁻¹ = ↑s ^ Int.negSucc n
Theorem: ConvexOn.le_right_of_left_le
File: Mathlib/Analysis/Convex/Function.lean

tactic: obtain ⟨a, b, ha, hb, hab, rfl⟩ := hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.553852
α : Type ?u.553855
β : Type u_3
ι : Type ?u.553861
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y z : E
hx : x ∈ s
hy : y ∈ s
hz : z ∈ openSegment 𝕜 x y
hxz : f x ≤ f z
⊢ f z ≤ f y

tactic: exact hf.le_right_of_left_le' hx hy ha.le hb hab hxz
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.553852
α : Type ?u.553855
β : Type u_3
ι : Type ?u.553861
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
hx : x ∈ s
hy : y ∈ s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hxz : f x ≤ f (a • x + b • y)
⊢ f (a • x + b • y) ≤ f y
Theorem: Rat.mkRat_mul_mkRat
File: Std/Data/Rat/Lemmas.lean

tactic: if z₁ : d₁ = 0 then simp [z₁] else if z₂ : d₂ = 0 then simp [z₂] else
rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_mul_normalize, normalize_eq_mkRat]
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
⊢ mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂)

tactic: simp [z₁]
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
z₁ : d₁ = 0
⊢ mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂)

tactic: if z₂ : d₂ = 0 then simp [z₂] else
rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_mul_normalize, normalize_eq_mkRat]
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
z₁ : ¬d₁ = 0
⊢ mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂)

tactic: simp [z₂]
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
z₁ : ¬d₁ = 0
z₂ : d₂ = 0
⊢ mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂)

tactic: rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_mul_normalize, normalize_eq_mkRat]
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
z₁ : ¬d₁ = 0
z₂ : ¬d₂ = 0
⊢ mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂)
Theorem: lift.SubfieldWithHom.compat
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

tactic: rw [le_def] at h
state_before: k : Type u
inst✝⁶ : Field k
K : Type u
L : Type v
M : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra K L
inst✝² : Field M
inst✝¹ : Algebra K M
inst✝ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
E₁ E₂ E₃ : SubfieldWithHom K L M
h : E₁ ≤ E₂
⊢ ∀ (x : { x // x ∈ E₁.carrier }), ↑E₂.emb (↑(inclusion (_ : E₁.carrier ≤ E₂.carrier)) x) = ↑E₁.emb x

tactic: cases h
state_before: k : Type u
inst✝⁶ : Field k
K : Type u
L : Type v
M : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra K L
inst✝² : Field M
inst✝¹ : Algebra K M
inst✝ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
E₁ E₂ E₃ : SubfieldWithHom K L M
h✝ : E₁ ≤ E₂
h : ∃ h, ∀ (x : { x // x ∈ E₁.carrier }), ↑E₂.emb (↑(inclusion h) x) = ↑E₁.emb x
⊢ ∀ (x : { x // x ∈ E₁.carrier }), ↑E₂.emb (↑(inclusion (_ : E₁.carrier ≤ E₂.carrier)) x) = ↑E₁.emb x

tactic: assumption
state_before: case intro
k : Type u
inst✝⁶ : Field k
K : Type u
L : Type v
M : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Algebra K L
inst✝² : Field M
inst✝¹ : Algebra K M
inst✝ : IsAlgClosed M
hL : Algebra.IsAlgebraic K L
E₁ E₂ E₃ : SubfieldWithHom K L M
h : E₁ ≤ E₂
w✝ : E₁.carrier ≤ E₂.carrier
h✝ : ∀ (x : { x // x ∈ E₁.carrier }), ↑E₂.emb (↑(inclusion w✝) x) = ↑E₁.emb x
⊢ ∀ (x : { x // x ∈ E₁.carrier }), ↑E₂.emb (↑(inclusion (_ : E₁.carrier ≤ E₂.carrier)) x) = ↑E₁.emb x
Theorem: PFunctor.M.isPath_cons'
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: generalize h : M.mk ⟨a, f⟩ = x
state_before: F : PFunctor
X : Type ?u.21403
f✝ : X → Obj F X
xs : Path F
a : F.A
f : B F a → M F
i : B F a
⊢ IsPath ({ fst := a, snd := i } :: xs) (M.mk { fst := a, snd := f }) → IsPath xs (f i)

tactic: rintro (_ | ⟨_, _, _, _, rfl, hp⟩)
state_before: F : PFunctor
X : Type ?u.21403
f✝ : X → Obj F X
xs : Path F
a : F.A
f : B F a → M F
i : B F a
x : M F
h : M.mk { fst := a, snd := f } = x
⊢ IsPath ({ fst := a, snd := i } :: xs) x → IsPath xs (f i)

tactic: cases mk_inj h
state_before: case cons
F : PFunctor
X : Type ?u.21403
f✝¹ : X → Obj F X
xs : Path F
a : F.A
f : B F a → M F
i : B F a
f✝ : B F a → M F
hp : IsPath xs (f✝ i)
h : M.mk { fst := a, snd := f } = M.mk { fst := a, snd := f✝ }
⊢ IsPath xs (f i)

tactic: exact hp
state_before: case cons.refl
F : PFunctor
X : Type ?u.21403
f✝ : X → Obj F X
xs : Path F
a : F.A
f : B F a → M F
i : B F a
hp : IsPath xs (f i)
h : M.mk { fst := a, snd := f } = M.mk { fst := a, snd := f }
⊢ IsPath xs (f i)
Theorem: Set.compl_sInter
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [sUnion_eq_compl_sInter_compl, compl_compl_image]
state_before: α : Type u_1
β : Type ?u.147726
γ : Type ?u.147729
ι : Sort ?u.147732
ι' : Sort ?u.147735
ι₂ : Sort ?u.147738
κ : ι → Sort ?u.147743
κ₁ : ι → Sort ?u.147748
κ₂ : ι → Sort ?u.147753
κ' : ι' → Sort ?u.147758
S : Set (Set α)
⊢ (⋂₀ S)ᶜ = ⋃₀ (compl '' S)
Theorem: LocalizedModule.liftOn₂_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: convert Quotient.liftOn₂_mk f wd _ _
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
α : Type u_1
f : M × { x // x ∈ S } → M × { x // x ∈ S } → α
wd : ∀ (p q p' q' : M × { x // x ∈ S }), p ≈ p' → q ≈ q' → f p q = f p' q'
m m' : M
s s' : { x // x ∈ S }
⊢ liftOn₂ (mk m s) (mk m' s') f wd = f (m, s) (m', s')
Theorem: Algebra.mem_bot
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: rw [← this, ← SetLike.mem_coe, AlgHom.coe_range]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A
this : AlgHom.range (ofId R A) = ⊥
⊢ x ∈ ⊥ ↔ x ∈ Set.range ↑(algebraMap R A)

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A
this : AlgHom.range (ofId R A) = ⊥
⊢ x ∈ Set.range ↑(ofId R A) ↔ x ∈ Set.range ↑(algebraMap R A)
Theorem: CategoryTheory.Limits.id_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: apply HasZeroObject.from_zero_ext
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
⊢ 𝟙 0 = 0
Theorem: Finset.uIcc_subset_uIcc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [mem_uIcc] at h₁ h₂
state_before: ι : Type ?u.184228
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₁ ∈ [[a₂, b₂]]
h₂ : b₁ ∈ [[a₂, b₂]]
⊢ [[a₁, b₁]] ⊆ [[a₂, b₂]]

tactic: exact Icc_subset_Icc (_root_.le_inf h₁.1 h₂.1) (_root_.sup_le h₁.2 h₂.2)
state_before: ι : Type ?u.184228
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₂ ⊓ b₂ ≤ a₁ ∧ a₁ ≤ a₂ ⊔ b₂
h₂ : a₂ ⊓ b₂ ≤ b₁ ∧ b₁ ≤ a₂ ⊔ b₂
⊢ [[a₁, b₁]] ⊆ [[a₂, b₂]]
Theorem: Ordinal.lift_pred
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: cases' h with a e
state_before: α : Type ?u.88270
β : Type ?u.88273
γ : Type ?u.88276
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : ∃ a, o = succ a
⊢ lift (pred o) = pred (lift o)

tactic: simp only [e, pred_succ, lift_succ]
state_before: case intro
α : Type ?u.88270
β : Type ?u.88273
γ : Type ?u.88276
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o a : Ordinal
e : o = succ a
⊢ lift (pred o) = pred (lift o)

tactic: rw [pred_eq_iff_not_succ.2 h, pred_eq_iff_not_succ.2 (mt lift_is_succ.1 h)]
state_before: α : Type ?u.88270
β : Type ?u.88273
γ : Type ?u.88276
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : ¬∃ a, o = succ a
⊢ lift (pred o) = pred (lift o)
Theorem: IntervalIntegrable.comp_sub_left
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [neg_sub, ← sub_eq_add_neg] using iff_comp_neg.mp (hf.comp_add_left c)
state_before: ι : Type ?u.7793606
𝕜 : Type ?u.7793609
E : Type u_1
F : Type ?u.7793615
A : Type ?u.7793618
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f g : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
hf : IntervalIntegrable f volume a b
c : ℝ
⊢ IntervalIntegrable (fun x => f (c - x)) volume (c - a) (c - b)
Theorem: Real.IsConjugateExponent.conj_eq
File: Mathlib/Data/Real/ConjugateExponents.lean

tactic: have := h.inv_add_inv_conj
state_before: p q : ℝ
h : IsConjugateExponent p q
⊢ q = p / (p - 1)

tactic: rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this
state_before: p q : ℝ
h : IsConjugateExponent p q
this : 1 / p + 1 / q = 1
⊢ q = p / (p - 1)

tactic: field_simp [this, h.ne_zero]
state_before: p q : ℝ
h : IsConjugateExponent p q
this : q = (1 - 1 / p)⁻¹
⊢ q = p / (p - 1)
Theorem: LieModuleHom.coe_mk
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rfl
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
P : Type w₂
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieRingModule L N
inst✝³ : LieRingModule L P
inst✝² : LieModule R L M
inst✝¹ : LieModule R L N
inst✝ : LieModule R L P
f : M →ₗ[R] N
h : ∀ {x : L} {m : M}, AddHom.toFun f.toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun f.toAddHom m⁆
⊢ ↑{ toLinearMap := f, map_lie' := h } = ↑f
Theorem: Complex.cosh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [add_comm, cosh, exp_neg]
state_before: x y : ℂ
⊢ cosh (-x) = cosh x
Theorem: MeasureTheory.integrable_finset_sum
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simpa only [← Finset.sum_apply] using integrable_finset_sum' s hf
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.948084
δ : Type ?u.948087
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
ι : Type u_1
s : Finset ι
f : ι → α → β
hf : ∀ (i : ι), i ∈ s → Integrable (f i)
⊢ Integrable fun a => ∑ i in s, f i a
Theorem: PFun.id_comp
File: Mathlib/Data/PFun.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.53166
δ : Type ?u.53169
ε : Type ?u.53172
ι : Type ?u.53175
f✝ f : α →. β
x✝¹ : α
x✝ : β
⊢ x✝ ∈ comp (PFun.id β) f x✝¹ ↔ x✝ ∈ f x✝¹
Theorem: PowerSeries.coeff_coe
File: Mathlib/RingTheory/LaurentSeries.lean

tactic: cases i
state_before: R : Type u
R' : Type ?u.236572
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : PowerSeries R
f' g' : PowerSeries R'
i : ℤ
⊢ HahnSeries.coeff (↑(ofPowerSeries ℤ R) f) i = if i < 0 then 0 else ↑(coeff R (Int.natAbs i)) f

tactic: rw [Int.ofNat_eq_coe, coeff_coe_powerSeries, if_neg (Int.coe_nat_nonneg _).not_lt,
  Int.natAbs_ofNat]
state_before: case ofNat
R : Type u
R' : Type ?u.236572
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : PowerSeries R
f' g' : PowerSeries R'
a✝ : ℕ
⊢ HahnSeries.coeff (↑(ofPowerSeries ℤ R) f) (Int.ofNat a✝) =
    if Int.ofNat a✝ < 0 then 0 else ↑(coeff R (Int.natAbs (Int.ofNat a✝))) f

tactic: rw [ofPowerSeries_apply, embDomain_notin_image_support, if_pos (Int.negSucc_lt_zero _)]
state_before: case negSucc
R : Type u
R' : Type ?u.236572
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : PowerSeries R
f' g' : PowerSeries R'
a✝ : ℕ
⊢ HahnSeries.coeff (↑(ofPowerSeries ℤ R) f) (Int.negSucc a✝) =
    if Int.negSucc a✝ < 0 then 0 else ↑(coeff R (Int.natAbs (Int.negSucc a✝))) f

tactic: simp only [not_exists, RelEmbedding.coe_mk, Set.mem_image, not_and, Function.Embedding.coeFn_mk,
  Ne.def, toPowerSeries_symm_apply_coeff, mem_support, imp_true_iff,
  not_false_iff]
state_before: case negSucc
R : Type u
R' : Type ?u.236572
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : PowerSeries R
f' g' : PowerSeries R'
a✝ : ℕ
⊢ ¬Int.negSucc a✝ ∈
      ↑{ toEmbedding := { toFun := Nat.cast, inj' := (_ : Function.Injective Nat.cast) },
            map_rel_iff' :=
              (_ :
                ∀ {a b : ℕ},
                  ↑{ toFun := Nat.cast, inj' := (_ : Function.Injective Nat.cast) } a ≤
                      ↑{ toFun := Nat.cast, inj' := (_ : Function.Injective Nat.cast) } b ↔
                    a ≤ b) } ''
        HahnSeries.support (↑(RingEquiv.symm toPowerSeries) f)
Theorem: List.get?_zip_with
File: Mathlib/Data/List/Zip.lean

tactic: induction' l₁ with head tail generalizing l₂ i
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₁ : List α
l₂ : List β
i : ℕ
⊢ get? (zipWith f l₁ l₂) i = Option.bind (Option.map f (get? l₁ i)) fun g => Option.map g (get? l₂ i)

tactic: rw [zipWith] <;> simp
state_before: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₂✝ : List β
i✝ : ℕ
l₂ : List β
i : ℕ
⊢ get? (zipWith f [] l₂) i = Option.bind (Option.map f (get? [] i)) fun g => Option.map g (get? l₂ i)

tactic: cases l₂
state_before: case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₂✝ : List β
i✝ : ℕ
head : α
tail : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ),
    get? (zipWith f tail l₂) i = Option.bind (Option.map f (get? tail i)) fun g => Option.map g (get? l₂ i)
l₂ : List β
i : ℕ
⊢ get? (zipWith f (head :: tail) l₂) i =
    Option.bind (Option.map f (get? (head :: tail) i)) fun g => Option.map g (get? l₂ i)

tactic: simp only [zipWith, Seq.seq, Functor.map, get?, Option.map_none']
state_before: case cons.nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₂ : List β
i✝ : ℕ
head : α
tail : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ),
    get? (zipWith f tail l₂) i = Option.bind (Option.map f (get? tail i)) fun g => Option.map g (get? l₂ i)
i : ℕ
⊢ get? (zipWith f (head :: tail) []) i =
    Option.bind (Option.map f (get? (head :: tail) i)) fun g => Option.map g (get? [] i)

case cons.cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₂ : List β
i✝ : ℕ
head : α
tail : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ),
    get? (zipWith f tail l₂) i = Option.bind (Option.map f (get? tail i)) fun g => Option.map g (get? l₂ i)
i : ℕ
head✝ : β
tail✝ : List β
⊢ get? (zipWith f (head :: tail) (head✝ :: tail✝)) i =
    Option.bind (Option.map f (get? (head :: tail) i)) fun g => Option.map g (get? (head✝ :: tail✝) i)

tactic: cases (head :: tail).get? i <;> rfl
state_before: case cons.nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₂ : List β
i✝ : ℕ
head : α
tail : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ),
    get? (zipWith f tail l₂) i = Option.bind (Option.map f (get? tail i)) fun g => Option.map g (get? l₂ i)
i : ℕ
⊢ none = Option.bind (Option.map f (get? (head :: tail) i)) fun g => none

tactic: cases i <;> simp only [Option.map_some', get?, Option.some_bind', *]
state_before: case cons.cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.94446
ε : Type ?u.94449
f : α → β → γ
l₂ : List β
i✝ : ℕ
head : α
tail : List α
tail_ih✝ :
  ∀ (l₂ : List β) (i : ℕ),
    get? (zipWith f tail l₂) i = Option.bind (Option.map f (get? tail i)) fun g => Option.map g (get? l₂ i)
i : ℕ
head✝ : β
tail✝ : List β
⊢ get? (zipWith f (head :: tail) (head✝ :: tail✝)) i =
    Option.bind (Option.map f (get? (head :: tail) i)) fun g => Option.map g (get? (head✝ :: tail✝) i)
Theorem: Set.mem_image_iff_of_inverse
File: Mathlib/Data/Set/Image.lean

tactic: rw [image_eq_preimage_of_inverse h₁ h₂]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45305
ι : Sort ?u.45308
ι' : Sort ?u.45311
f✝ : α → β
s✝ t : Set α
f : α → β
g : β → α
b : β
s : Set α
h₁ : LeftInverse g f
h₂ : Function.RightInverse g f
⊢ b ∈ f '' s ↔ g b ∈ s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45305
ι : Sort ?u.45308
ι' : Sort ?u.45311
f✝ : α → β
s✝ t : Set α
f : α → β
g : β → α
b : β
s : Set α
h₁ : LeftInverse g f
h₂ : Function.RightInverse g f
⊢ b ∈ g ⁻¹' s ↔ g b ∈ s