tasksource/leandojo huggingface dataset:
Theorem: Finset.centerMass_eq_of_sum_1
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp only [Finset.centerMass, hw, inv_one, one_smul]
state_before: R : Type u_1
E : Type u_3
F : Type ?u.30257
ι : Type u_2
ι' : Type ?u.30263
α : Type ?u.30266
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
hw : ∑ i in t, w i = 1
⊢ centerMass t w z = ∑ i in t, w i • z i
Theorem: Real.cos_pi_div_six
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: suffices sqrt 3 = cos (π / 6) * 2 by
  field_simp [(by norm_num : 0 ≠ 2)]
  exact this.symm
state_before: x : ℝ
⊢ cos (π / 6) = sqrt 3 / 2

tactic: rw [sqrt_eq_iff_sq_eq]
state_before: x : ℝ
⊢ sqrt 3 = cos (π / 6) * 2

tactic: field_simp [(by norm_num : 0 ≠ 2)]
state_before: x : ℝ
this : sqrt 3 = cos (π / 6) * 2
⊢ cos (π / 6) = sqrt 3 / 2

tactic: exact this.symm
state_before: x : ℝ
this : sqrt 3 = cos (π / 6) * 2
⊢ cos (π / 6) * 2 = sqrt 3

tactic: norm_num
state_before: x : ℝ
this : sqrt 3 = cos (π / 6) * 2
⊢ 0 ≠ 2

tactic: have h1 := (mul_right_inj' (by norm_num : (4 : ℝ) ≠ 0)).mpr sq_cos_pi_div_six
state_before: x : ℝ
⊢ (cos (π / 6) * 2) ^ 2 = 3

tactic: rw [← sub_eq_zero] at h1⊢
state_before: x : ℝ
h1 : 4 * cos (π / 6) ^ 2 = 4 * (3 / 4)
⊢ (cos (π / 6) * 2) ^ 2 = 3

tactic: convert h1 using 1
state_before: x : ℝ
h1✝ : 4 * cos (π / 6) ^ 2 = 4 * (3 / 4)
h1 : 4 * cos (π / 6) ^ 2 - 4 * (3 / 4) = 0
⊢ (cos (π / 6) * 2) ^ 2 - 3 = 0

tactic: ring
state_before: case h.e'_2
x : ℝ
h1✝ : 4 * cos (π / 6) ^ 2 = 4 * (3 / 4)
h1 : 4 * cos (π / 6) ^ 2 - 4 * (3 / 4) = 0
⊢ (cos (π / 6) * 2) ^ 2 - 3 = 4 * cos (π / 6) ^ 2 - 4 * (3 / 4)

tactic: norm_num
state_before: x : ℝ
⊢ 4 ≠ 0

tactic: norm_num
state_before: case hx
x : ℝ
⊢ 0 ≤ 3

tactic: have : 0 < cos (π / 6) := by apply cos_pos_of_mem_Ioo; constructor <;> linarith [pi_pos]
state_before: case hy
x : ℝ
⊢ 0 ≤ cos (π / 6) * 2

tactic: linarith
state_before: case hy
x : ℝ
this : 0 < cos (π / 6)
⊢ 0 ≤ cos (π / 6) * 2

tactic: apply cos_pos_of_mem_Ioo
state_before: x : ℝ
⊢ 0 < cos (π / 6)

tactic: constructor <;> linarith [pi_pos]
state_before: case hx
x : ℝ
⊢ π / 6 ∈ Ioo (-(π / 2)) (π / 2)
Theorem: FirstOrder.Language.Theory.CompleteType.not_mem_iff
File: Mathlib/ModelTheory/Types.lean

tactic: have h : ¬IsSatisfiable ({φ, φ.not} : L[[α]].Theory) := by
  rintro ⟨@⟨_, _, h, _⟩⟩
  simp only [model_iff, mem_insert_iff, mem_singleton_iff, forall_eq_or_imp, forall_eq] at h
  exact h.2 h.1
state_before: L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
⊢ False

tactic: refine' h (p.isMaximal.1.mono _)
state_before: L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
h : ¬IsSatisfiable {φ, Formula.not φ}
⊢ False

tactic: rw [insert_subset, singleton_subset_iff]
state_before: L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
h : ¬IsSatisfiable {φ, Formula.not φ}
⊢ {φ, Formula.not φ} ⊆ ↑p

tactic: exact ⟨ht, hf⟩
state_before: L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
h : ¬IsSatisfiable {φ, Formula.not φ}
⊢ φ ∈ ↑p ∧ Formula.not φ ∈ ↑p

tactic: rintro ⟨@⟨_, _, h, _⟩⟩
state_before: L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
⊢ ¬IsSatisfiable {φ, Formula.not φ}

tactic: simp only [model_iff, mem_insert_iff, mem_singleton_iff, forall_eq_or_imp, forall_eq] at h
state_before: case intro.mk
L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
Carrier✝ : Type (max (max u w) v)
struc✝ : Structure (L[[α]]) Carrier✝
h : Carrier✝ ⊨ {φ, Formula.not φ}
nonempty'✝ : Nonempty Carrier✝
⊢ False

tactic: exact h.2 h.1
state_before: case intro.mk
L : Language
T : Theory L
α : Type w
p : CompleteType T α
φ : Sentence (L[[α]])
hf : Formula.not φ ∈ p
ht : φ ∈ p
Carrier✝ : Type (max (max u w) v)
struc✝ : Structure (L[[α]]) Carrier✝
nonempty'✝ : Nonempty Carrier✝
h : Carrier✝ ⊨ φ ∧ Carrier✝ ⊨ Formula.not φ
⊢ False
Theorem: Polynomial.Monic.add_of_left
File: Mathlib/Data/Polynomial/Monic.lean

tactic: rwa [Monic, add_comm, leadingCoeff_add_of_degree_lt hpq]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hpq : degree q < degree p
⊢ Monic (p + q)
Theorem: QuadraticForm.associated_linMulLin
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: ext
state_before: S : Type ?u.466182
R : Type ?u.466185
R₁ : Type u_1
M : Type u_2
inst✝³ : CommRing R₁
inst✝² : AddCommGroup M
inst✝¹ : Module R₁ M
inst✝ : Invertible 2
f g : M →ₗ[R₁] R₁
⊢ ↑associated (linMulLin f g) = ⅟2 • (BilinForm.linMulLin f g + BilinForm.linMulLin g f)

tactic: simp only [smul_add, Algebra.id.smul_eq_mul, BilinForm.linMulLin_apply,
  QuadraticForm.linMulLin_apply, BilinForm.smul_apply, associated_apply, BilinForm.add_apply,
  LinearMap.map_add]
state_before: case H
S : Type ?u.466182
R : Type ?u.466185
R₁ : Type u_1
M : Type u_2
inst✝³ : CommRing R₁
inst✝² : AddCommGroup M
inst✝¹ : Module R₁ M
inst✝ : Invertible 2
f g : M →ₗ[R₁] R₁
x✝ y✝ : M
⊢ bilin (↑associated (linMulLin f g)) x✝ y✝ = bilin (⅟2 • (BilinForm.linMulLin f g + BilinForm.linMulLin g f)) x✝ y✝

tactic: ring
state_before: case H
S : Type ?u.466182
R : Type ?u.466185
R₁ : Type u_1
M : Type u_2
inst✝³ : CommRing R₁
inst✝² : AddCommGroup M
inst✝¹ : Module R₁ M
inst✝ : Invertible 2
f g : M →ₗ[R₁] R₁
x✝ y✝ : M
⊢ ⅟2 * ((↑f x✝ + ↑f y✝) * (↑g x✝ + ↑g y✝) - ↑f x✝ * ↑g x✝ - ↑f y✝ * ↑g y✝) = ⅟2 * (↑f x✝ * ↑g y✝) + ⅟2 * (↑g x✝ * ↑f y✝)
Theorem: HasFDerivAt.le_of_lip
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: refine' hf.le_of_lip' C.coe_nonneg _
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.148111
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.148206
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E →L[𝕜] F
x₀ : E
hf : HasFDerivAt f f' x₀
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ‖f'‖ ≤ ↑C

tactic: filter_upwards [hs]with x hx using hlip.norm_sub_le hx (mem_of_mem_nhds hs)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.148111
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.148206
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E →L[𝕜] F
x₀ : E
hf : HasFDerivAt f f' x₀
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ∀ᶠ (x : E) in 𝓝 x₀, ‖f x - f x₀‖ ≤ ↑C * ‖x - x₀‖
Theorem: Cardinal.ord_aleph0
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rcases Ordinal.lt_lift_iff.1 h with ⟨o, rfl, h'⟩
state_before: o : Ordinal
h : o < ω
⊢ o < ord ℵ₀

tactic: exact lt_aleph0_iff_fintype.2 ⟨Set.fintypeLTNat _⟩
state_before: case intro.intro
o : Ordinal
h' : o < type fun x x_1 => x < x_1
h : Ordinal.lift o < ω
⊢ card (typein (fun x x_1 => x < x_1) (enum (fun x x_1 => x < x_1) o h')) < ℵ₀
Theorem: Encodable.iUnion_decode₂_cases
File: Mathlib/Logic/Encodable/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝ : Encodable β
f : β → Set α
C : Set α → Prop
H0 : C ∅
H1 : ∀ (b : β), C (f b)
n : ℕ
⊢ C (⋃ (b : β) (_ : b ∈ none), f b)

tactic: apply H0
state_before: α : Type u_1
β : Type u_2
inst✝ : Encodable β
f : β → Set α
C : Set α → Prop
H0 : C ∅
H1 : ∀ (b : β), C (f b)
n : ℕ
⊢ C ∅

tactic: convert H1 b
state_before: α : Type u_1
β : Type u_2
inst✝ : Encodable β
f : β → Set α
C : Set α → Prop
H0 : C ∅
H1 : ∀ (b : β), C (f b)
n : ℕ
b : β
⊢ C (⋃ (b_1 : β) (_ : b_1 ∈ some b), f b_1)

tactic: simp [ext_iff]
state_before: case h.e'_1
α : Type u_1
β : Type u_2
inst✝ : Encodable β
f : β → Set α
C : Set α → Prop
H0 : C ∅
H1 : ∀ (b : β), C (f b)
n : ℕ
b : β
⊢ (⋃ (b_1 : β) (_ : b_1 ∈ some b), f b_1) = f b
Theorem: Sum.noMinOrder_iff
File: Mathlib/Data/Sum/Order.lean

tactic: obtain ⟨b | b, h⟩ := exists_lt (inl a : Sum α β)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.14611
δ : Type ?u.14614
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : α
⊢ ∃ b, b < a

tactic: exact ⟨b, inl_lt_inl_iff.1 h⟩
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type ?u.14611
δ : Type ?u.14614
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a b : α
h : inl b < inl a
⊢ ∃ b, b < a

tactic: exact (not_inr_lt_inl h).elim
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type ?u.14611
δ : Type ?u.14614
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : α
b : β
h : inr b < inl a
⊢ ∃ b, b < a

tactic: obtain ⟨b | b, h⟩ := exists_lt (inr a : Sum α β)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.14611
δ : Type ?u.14614
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : β
⊢ ∃ b, b < a

tactic: exact (not_inl_lt_inr h).elim
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type ?u.14611
δ : Type ?u.14614
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : β
b : α
h : inl b < inr a
⊢ ∃ b, b < a

tactic: exact ⟨b, inr_lt_inr_iff.1 h⟩
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type ?u.14611
δ : Type ?u.14614
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a b : β
h : inr b < inr a
⊢ ∃ b, b < a
Theorem: Submonoid.fg_iff_add_fg
File: Mathlib/GroupTheory/Finiteness.lean

tactic: simp [← Submonoid.toAddSubmonoid_closure, hS]
state_before: M : Type u_1
N : Type ?u.2057
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : Submonoid M
h : FG P
S : Set M
hS : closure S = P
hf : Set.Finite S
⊢ AddSubmonoid.closure (↑Additive.toMul ⁻¹' S) = ↑toAddSubmonoid P

tactic: simp [← AddSubmonoid.toSubmonoid'_closure, hT]
state_before: M : Type u_1
N : Type ?u.2057
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : Submonoid M
h : AddSubmonoid.FG (↑toAddSubmonoid P)
T : Set (Additive M)
hT : AddSubmonoid.closure T = ↑toAddSubmonoid P
hf : Set.Finite T
⊢ closure (↑Multiplicative.ofAdd ⁻¹' T) = P
Theorem: Polynomial.eraseLead_natDegree_le
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: rcases f.eraseLead_natDegree_lt_or_eraseLead_eq_zero with (h | h)
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ natDegree (eraseLead f) ≤ natDegree f - 1

tactic: exact Nat.le_pred_of_lt h
state_before: case inl
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : natDegree (eraseLead f) < natDegree f
⊢ natDegree (eraseLead f) ≤ natDegree f - 1

tactic: simp only [h, natDegree_zero, zero_le]
state_before: case inr
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : eraseLead f = 0
⊢ natDegree (eraseLead f) ≤ natDegree f - 1
Theorem: Ideal.exists_mul_sub_mem_of_sub_one_mem_jacobson
File: Mathlib/RingTheory/JacobsonIdeal.lean

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

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

tactic: simpa [mul_sub] using hs
state_before: case intro
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I : Ideal R
r : R
h : r - 1 ∈ jacobson I
s : R
hs : s * 1 * (r - 1) + s - 1 ∈ I
⊢ s * r - 1 ∈ I
Theorem: LinearMap.adjoint_inner_left
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [← coe_toContinuousLinearMap A, adjoint_eq_toClm_adjoint]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1665131
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
x : E
y : F
⊢ inner (↑(↑adjoint A) y) x = inner y (↑A x)

tactic: exact ContinuousLinearMap.adjoint_inner_left _ x y
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1665131
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
x : E
y : F
⊢ inner (↑↑(↑ContinuousLinearMap.adjoint (↑toContinuousLinearMap ↑(↑toContinuousLinearMap A))) y) x =
    inner y (↑↑(↑toContinuousLinearMap A) x)
Theorem: bit1_pos'
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: nontriviality
state_before: α : Type u
β : Type ?u.25897
inst✝ : OrderedSemiring α
a b c d : α
h : 0 < a
⊢ 0 < bit1 a

tactic: exact bit1_pos h.le
state_before: α : Type u
β : Type ?u.25897
inst✝¹ : OrderedSemiring α
a b c d : α
h : 0 < a
inst✝ : Nontrivial α
⊢ 0 < bit1 a
Theorem: Real.inv_one_add_tan_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: simpa using Complex.inv_one_add_tan_sq this
state_before: x✝ y x : ℝ
hx : cos x ≠ 0
this : Complex.cos ↑x ≠ 0
⊢ ↑(1 + tan x ^ 2)⁻¹ = ↑(cos x ^ 2)
Theorem: Finset.filter_le_lt_eq_Ico
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.39550
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j < b
⊢ filter (fun j => a ≤ j ∧ j < b) univ = Ico a b

tactic: simp
state_before: case a
ι : Type ?u.39550
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j < b
a✝ : α
⊢ a✝ ∈ filter (fun j => a ≤ j ∧ j < b) univ ↔ a✝ ∈ Ico a b
Theorem: MeasureTheory.set_integral_map
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [Measure.restrict_map_of_aemeasurable hg hs,
  integral_map (hg.mono_measure Measure.restrict_le_self) (hf.mono_measure _)]
state_before: α : Type u_3
β✝ : Type ?u.135307
E : Type u_2
F : Type ?u.135313
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
β : Type u_1
inst✝ : MeasurableSpace β
g : α → β
f : β → E
s : Set β
hs : MeasurableSet s
hf : AEStronglyMeasurable f (Measure.map g μ)
hg : AEMeasurable g
⊢ (∫ (y : β) in s, f y ∂Measure.map g μ) = ∫ (x : α) in g ⁻¹' s, f (g x) ∂μ

tactic: exact Measure.map_mono_of_aemeasurable Measure.restrict_le_self hg
state_before: α : Type u_3
β✝ : Type ?u.135307
E : Type u_2
F : Type ?u.135313
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
β : Type u_1
inst✝ : MeasurableSpace β
g : α → β
f : β → E
s : Set β
hs : MeasurableSet s
hf : AEStronglyMeasurable f (Measure.map g μ)
hg : AEMeasurable g
⊢ Measure.map g (Measure.restrict μ (g ⁻¹' s)) ≤ Measure.map g μ
Theorem: FirstOrder.Language.LHom.comp_onTerm
File: Mathlib/ModelTheory/Syntax.lean

tactic: ext t
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.28526
P : Type ?u.28529
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28557
L'' : Language
φ : L' →ᴸ L''
ψ : L →ᴸ L'
⊢ onTerm (comp φ ψ) = onTerm φ ∘ onTerm ψ

tactic: induction' t with _ _ _ _ ih
state_before: case h
L : Language
L' : Language
M : Type w
N : Type ?u.28526
P : Type ?u.28529
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28557
L'' : Language
φ : L' →ᴸ L''
ψ : L →ᴸ L'
t : Term L α
⊢ onTerm (comp φ ψ) t = (onTerm φ ∘ onTerm ψ) t

tactic: rfl
state_before: case h.var
L : Language
L' : Language
M : Type w
N : Type ?u.28526
P : Type ?u.28529
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28557
L'' : Language
φ : L' →ᴸ L''
ψ : L →ᴸ L'
_a✝ : α
⊢ onTerm (comp φ ψ) (var _a✝) = (onTerm φ ∘ onTerm ψ) (var _a✝)

tactic: simp_rw [onTerm, ih]
state_before: case h.func
L : Language
L' : Language
M : Type w
N : Type ?u.28526
P : Type ?u.28529
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28557
L'' : Language
φ : L' →ᴸ L''
ψ : L →ᴸ L'
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih : ∀ (a : Fin l✝), onTerm (comp φ ψ) (_ts✝ a) = (onTerm φ ∘ onTerm ψ) (_ts✝ a)
⊢ onTerm (comp φ ψ) (func _f✝ _ts✝) = (onTerm φ ∘ onTerm ψ) (func _f✝ _ts✝)

tactic: rfl
state_before: case h.func
L : Language
L' : Language
M : Type w
N : Type ?u.28526
P : Type ?u.28529
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28557
L'' : Language
φ : L' →ᴸ L''
ψ : L →ᴸ L'
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih : ∀ (a : Fin l✝), onTerm (comp φ ψ) (_ts✝ a) = (onTerm φ ∘ onTerm ψ) (_ts✝ a)
⊢ (func (onFunction (comp φ ψ) _f✝) fun i => (onTerm φ ∘ onTerm ψ) (_ts✝ i)) = (onTerm φ ∘ onTerm ψ) (func _f✝ _ts✝)
Theorem: bddAbove_range_partialSups
File: Mathlib/Order/PartialSups.lean

tactic: apply exists_congr fun a => _
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
⊢ BddAbove (Set.range ↑(partialSups f)) ↔ BddAbove (Set.range f)

tactic: intro a
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
⊢ ∀ (a : α), a ∈ upperBounds (Set.range ↑(partialSups f)) ↔ a ∈ upperBounds (Set.range f)

tactic: constructor
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
a : α
⊢ a ∈ upperBounds (Set.range ↑(partialSups f)) ↔ a ∈ upperBounds (Set.range f)

tactic: rintro h b ⟨i, rfl⟩
state_before: case mp
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
a : α
⊢ a ∈ upperBounds (Set.range ↑(partialSups f)) → a ∈ upperBounds (Set.range f)

tactic: exact (le_partialSups _ _).trans (h (Set.mem_range_self i))
state_before: case mp.intro
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
a : α
h : a ∈ upperBounds (Set.range ↑(partialSups f))
i : ℕ
⊢ f i ≤ a

tactic: rintro h b ⟨i, rfl⟩
state_before: case mpr
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
a : α
⊢ a ∈ upperBounds (Set.range f) → a ∈ upperBounds (Set.range ↑(partialSups f))

tactic: exact partialSups_le _ _ _ fun _ _ => h (Set.mem_range_self _)
state_before: case mpr.intro
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
a : α
h : a ∈ upperBounds (Set.range f)
i : ℕ
⊢ ↑(partialSups f) i ≤ a
Theorem: tsum_eq_add_tsum_ite
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [(hasSum_ite_sub_hasSum hf.hasSum b).tsum_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.448190
δ : Type ?u.448193
inst✝⁴ : AddCommGroup α
inst✝³ : TopologicalSpace α
inst✝² : TopologicalAddGroup α
f g : β → α
a a₁ a₂ : α
inst✝¹ : T2Space α
inst✝ : DecidableEq β
hf : Summable f
b : β
⊢ (∑' (n : β), f n) = f b + ∑' (n : β), if n = b then 0 else f n

tactic: exact (add_sub_cancel'_right _ _).symm
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.448190
δ : Type ?u.448193
inst✝⁴ : AddCommGroup α
inst✝³ : TopologicalSpace α
inst✝² : TopologicalAddGroup α
f g : β → α
a a₁ a₂ : α
inst✝¹ : T2Space α
inst✝ : DecidableEq β
hf : Summable f
b : β
⊢ (∑' (n : β), f n) = f b + ((∑' (b : β), f b) - f b)
Theorem: Int.induction_on
File: Mathlib/Data/Int/Basic.lean

tactic: induction i with
| ofNat i =>
  induction i with
  | zero => exact hz
  | succ i ih => exact hp _ ih
| negSucc i =>
  suffices ∀ n : ℕ, p (-n) from this (i + 1)
  intro n; induction n with
  | zero => simp [hz, Nat.cast_zero]
  | succ n ih => convert hn _ ih using 1; simp [sub_eq_neg_add]
state_before: p : ℤ → Prop
i : ℤ
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
⊢ p i

tactic: induction i with
| zero => exact hz
| succ i ih => exact hp _ ih
state_before: case ofNat
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ p (ofNat i)

tactic: exact hz
state_before: case ofNat.zero
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
⊢ p (ofNat zero)

tactic: exact hp _ ih
state_before: case ofNat.succ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
ih : p (ofNat i)
⊢ p (ofNat (Nat.succ i))

tactic: suffices ∀ n : ℕ, p (-n) from this (i + 1)
state_before: case negSucc
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ p -[i+1]

tactic: intro n
state_before: case negSucc
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ ∀ (n : ℕ), p (-↑n)

tactic: induction n with
| zero => simp [hz, Nat.cast_zero]
| succ n ih => convert hn _ ih using 1; simp [sub_eq_neg_add]
state_before: case negSucc
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
⊢ p (-↑n)

tactic: simp [hz, Nat.cast_zero]
state_before: case negSucc.zero
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i : ℕ
⊢ p (-↑zero)

tactic: convert hn _ ih using 1
state_before: case negSucc.succ
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
ih : p (-↑n)
⊢ p (-↑(Nat.succ n))

tactic: simp [sub_eq_neg_add]
state_before: case h.e'_1
p : ℤ → Prop
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
i n : ℕ
ih : p (-↑n)
⊢ -↑(Nat.succ n) = -↑n - 1
Theorem: Finset.card_eq_two
File: Mathlib/Data/Finset/Card.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.60671
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ card s = 2 ↔ ∃ x y, x ≠ y ∧ s = {x, y}

tactic: rw [card_eq_succ]
state_before: case mp
α : Type u_1
β : Type ?u.60671
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ card s = 2 → ∃ x y, x ≠ y ∧ s = {x, y}

tactic: simp_rw [card_eq_one]
state_before: case mp
α : Type u_1
β : Type ?u.60671
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ a t, ¬a ∈ t ∧ insert a t = s ∧ card t = 1) → ∃ x y, x ≠ y ∧ s = {x, y}

tactic: rintro ⟨a, _, hab, rfl, b, rfl⟩
state_before: case mp
α : Type u_1
β : Type ?u.60671
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ a t, ¬a ∈ t ∧ insert a t = s ∧ ∃ a, t = {a}) → ∃ x y, x ≠ y ∧ s = {x, y}

tactic: exact ⟨a, b, not_mem_singleton.1 hab, rfl⟩
state_before: case mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.60671
t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
a b : α
hab : ¬a ∈ {b}
⊢ ∃ x y, x ≠ y ∧ {a, b} = {x, y}

tactic: rintro ⟨x, y, h, rfl⟩
state_before: case mpr
α : Type u_1
β : Type ?u.60671
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ x y, x ≠ y ∧ s = {x, y}) → card s = 2

tactic: exact card_doubleton h
state_before: case mpr.intro.intro.intro
α : Type u_1
β : Type ?u.60671
t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
x y : α
h : x ≠ y
⊢ card {x, y} = 2
Theorem: Set.ncard_pair
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_insert_of_not_mem, ncard_singleton]
state_before: α : Type u_1
β : Type ?u.13061
s t : Set α
a b x y : α
f : α → β
h : a ≠ b
⊢ ncard {a, b} = 2

tactic: simpa
state_before: α : Type u_1
β : Type ?u.13061
s t : Set α
a b x y : α
f : α → β
h : a ≠ b
⊢ ¬a ∈ {b}
Theorem: Finset.multiplicativeEnergy_pos_iff
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: simp_rw [not_and_or, not_nonempty_iff_eq_empty] at H
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < multiplicativeEnergy s t
H : ¬(Finset.Nonempty s ∧ Finset.Nonempty t)
⊢ False

tactic: obtain rfl | rfl := H <;> simp [Nat.not_lt_zero] at h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < multiplicativeEnergy s t
H : s = ∅ ∨ t = ∅
⊢ False