tasksource/leandojo huggingface dataset:
Theorem: Int.fmod_add_fdiv
File: Std/Data/Int/DivMod.lean

tactic: simp
state_before: a✝ : Nat
⊢ 0 + 0 = 0

tactic: show subNatNat (m % succ n) n + (↑(succ n * (m / succ n)) + n + 1) = (m + 1)
state_before: m n : Nat
⊢ fmod ↑(succ m) -[n+1] + -[n+1] * fdiv ↑(succ m) -[n+1] = ↑(succ m)

tactic: rw [Int.add_comm _ n, ← Int.add_assoc, ← Int.add_assoc,
  Int.subNatNat_eq_coe, Int.sub_add_cancel]
state_before: m n : Nat
⊢ subNatNat (m % succ n) n + (↑(succ n * (m / succ n)) + ↑n + 1) = ↑m + 1

tactic: rw [fmod_zero]
state_before: a✝ : Nat
⊢ fmod -[a✝+1] 0 + 0 * fdiv -[a✝+1] 0 = -[a✝+1]

tactic: rfl
state_before: a✝ : Nat
⊢ -[a✝+1] + 0 * fdiv -[a✝+1] 0 = -[a✝+1]

tactic: show subNatNat .. - (↑(succ n * (m / succ n)) + ↑(succ n)) = -↑(succ m)
state_before: m n : Nat
⊢ fmod -[m+1] ↑(succ n) + ↑(succ n) * fdiv -[m+1] ↑(succ n) = -[m+1]

tactic: rw [Int.subNatNat_eq_coe, ← Int.sub_sub, ← Int.neg_sub, Int.sub_sub, Int.sub_sub_self]
state_before: m n : Nat
⊢ subNatNat (succ n) (succ (m % succ n)) - (↑(succ n * (m / succ n)) + ↑(succ n)) = -↑(succ m)

tactic: show -(↑(succ m % succ n) : Int) + -↑(succ n * (succ m / succ n)) = -↑(succ m)
state_before: m n : Nat
⊢ fmod -[m+1] -[n+1] + -[n+1] * fdiv -[m+1] -[n+1] = -[m+1]

tactic: rw [← Int.neg_add]
state_before: m n : Nat
⊢ -↑(succ m % succ n) + -↑(succ n * (succ m / succ n)) = -↑(succ m)
Theorem: Set.Finite.union
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : Set.Finite s
ht : Set.Finite t
⊢ Set.Finite (s ∪ t)

tactic: cases ht
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
ht : Set.Finite t
a✝ : Fintype ↑s
⊢ Set.Finite (s ∪ t)

tactic: apply toFinite
state_before: case intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a✝¹ : Fintype ↑s
a✝ : Fintype ↑t
⊢ Set.Finite (s ∪ t)
Theorem: Matrix.nonsing_inv_mul_cancel_left
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp [← Matrix.mul_assoc, nonsing_inv_mul A h]
state_before: l : Type ?u.217592
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B✝ : Matrix n n α
B : Matrix n m α
h : IsUnit (det A)
⊢ A⁻¹ ⬝ (A ⬝ B) = B
Theorem: Cardinal.cantorFunction_le
File: Mathlib/Data/Real/Cardinality.lean

tactic: apply tsum_le_tsum _ (summable_cantor_function f h1 h2) (summable_cantor_function g h1 h2)
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
⊢ cantorFunction c f ≤ cantorFunction c g

tactic: intro n
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
⊢ ∀ (i : ℕ), cantorFunctionAux c f i ≤ cantorFunctionAux c g i

tactic: cases h : f n
state_before: c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

tactic: simp [h, cantorFunctionAux_nonneg h1]
state_before: case false
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = false
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

tactic: replace h3 : g n = true := h3 n h
state_before: case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

tactic: simp [h, h3]
state_before: case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
n : ℕ
h : f n = true
h3 : g n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n
Theorem: List.append_sublist_append_right
File: Std/Data/List/Lemmas.lean

tactic: have := h.reverse
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
⊢ l₁ <+ l₂

tactic: simp only [reverse_append, append_sublist_append_left, reverse_sublist] at this
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : reverse (l₁ ++ l) <+ reverse (l₂ ++ l)
⊢ l₁ <+ l₂

tactic: exact this
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
h : l₁ ++ l <+ l₂ ++ l
this : l₁ <+ l₂
⊢ l₁ <+ l₂
Theorem: Equiv.Perm.extendDomain_trans
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp [Perm.extendDomain, permCongr_trans]
state_before: α' : Type u_1
β' : Type u_2
e✝ : Perm α'
p : β' → Prop
inst✝ : DecidablePred p
f : α' ≃ Subtype p
e e' : Perm α'
⊢ (extendDomain e f).trans (extendDomain e' f) = extendDomain (e.trans e') f
Theorem: Set.toFinset_subset_toFinset
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [Finset.subset_iff, Set.subset_def]
state_before: α : Type u_1
β : Type ?u.82390
γ : Type ?u.82393
s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
⊢ toFinset s ⊆ toFinset t ↔ s ⊆ t
Theorem: GeneralizedContinuedFraction.first_numerator_eq
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [num_eq_conts_a, first_continuant_eq zeroth_s_eq]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
zeroth_s_eq : Stream'.Seq.get? g.s 0 = some gp
⊢ numerators g 1 = gp.b * g.h + gp.a
Theorem: Multiset.mem_antidiagonal
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: dsimp only [quot_mk_to_coe, antidiagonal_coe]
state_before: α : Type u_1
β : Type ?u.819
s : Multiset α
x : Multiset α × Multiset α
l : List α
⊢ x ∈ antidiagonal (Quotient.mk (isSetoid α) l) ↔ x.fst + x.snd = Quotient.mk (isSetoid α) l

tactic: refine' ⟨fun h => revzip_powersetAux h, fun h ↦ _⟩
state_before: α : Type u_1
β : Type ?u.819
s : Multiset α
x : Multiset α × Multiset α
l : List α
⊢ x ∈ ↑(revzip (powersetAux l)) ↔ x.fst + x.snd = ↑l

tactic: haveI := Classical.decEq α
state_before: α : Type u_1
β : Type ?u.819
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.fst + x.snd = ↑l
⊢ x ∈ ↑(revzip (powersetAux l))

tactic: simp only [revzip_powersetAux_lemma l revzip_powersetAux, h.symm, ge_iff_le, mem_coe,
  List.mem_map, mem_powersetAux]
state_before: α : Type u_1
β : Type ?u.819
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.fst + x.snd = ↑l
this : DecidableEq α
⊢ x ∈ ↑(revzip (powersetAux l))

tactic: cases' x with x₁ x₂
state_before: α : Type u_1
β : Type ?u.819
s : Multiset α
x : Multiset α × Multiset α
l : List α
h : x.fst + x.snd = ↑l
this : DecidableEq α
⊢ ∃ a, a ≤ x.fst + x.snd ∧ (a, x.fst + x.snd - a) = x

tactic: exact ⟨x₁, le_add_right _ _, by rw [add_tsub_cancel_left x₁ x₂]⟩
state_before: case mk
α : Type u_1
β : Type ?u.819
s : Multiset α
l : List α
this : DecidableEq α
x₁ x₂ : Multiset α
h : (x₁, x₂).fst + (x₁, x₂).snd = ↑l
⊢ ∃ a, a ≤ (x₁, x₂).fst + (x₁, x₂).snd ∧ (a, (x₁, x₂).fst + (x₁, x₂).snd - a) = (x₁, x₂)

tactic: rw [add_tsub_cancel_left x₁ x₂]
state_before: α : Type u_1
β : Type ?u.819
s : Multiset α
l : List α
this : DecidableEq α
x₁ x₂ : Multiset α
h : (x₁, x₂).fst + (x₁, x₂).snd = ↑l
⊢ (x₁, (x₁, x₂).fst + (x₁, x₂).snd - x₁) = (x₁, x₂)
Theorem: separationRel_iff_specializes
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: simp only [(𝓤 α).basis_sets.mem_separationRel, id, mem_setOf_eq,
  (nhds_basis_uniformity (𝓤 α).basis_sets).specializes_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a b : α
⊢ (a, b) ∈ 𝓢 α ↔ a ⤳ b
Theorem: Polynomial.map_roots_le_of_injective
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hp0 : p = 0
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
⊢ Multiset.map (↑f) (roots p) ≤ roots (map f p)

tactic: exact map_roots_le ((Polynomial.map_ne_zero_iff hf).mpr hp0)
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hp0 : ¬p = 0
⊢ Multiset.map (↑f) (roots p) ≤ roots (map f p)

tactic: simp only [hp0, roots_zero, Multiset.map_zero, Polynomial.map_zero]
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hp0 : p = 0
⊢ Multiset.map (↑f) (roots p) ≤ roots (map f p)

tactic: rfl
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hp0 : p = 0
⊢ 0 ≤ 0
Theorem: Quotient.inductionOn₃
File: src/lean/Init/Core.lean

tactic: induction q₁ using Quotient.ind
state_before: a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
s₃ : Setoid φ
motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop
q₁ : Quotient s₁
q₂ : Quotient s₂
q₃ : Quotient s₃
h : ∀ (a : α) (b : β) (c : φ), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c)
⊢ motive q₁ q₂ q₃

tactic: induction q₂ using Quotient.ind
state_before: case a
a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
s₃ : Setoid φ
motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop
q₂ : Quotient s₂
q₃ : Quotient s₃
h : ∀ (a : α) (b : β) (c : φ), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c)
a✝ : α
⊢ motive (Quotient.mk s₁ a✝) q₂ q₃

tactic: induction q₃ using Quotient.ind
state_before: case a.a
a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
s₃ : Setoid φ
motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop
q₃ : Quotient s₃
h : ∀ (a : α) (b : β) (c : φ), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c)
a✝¹ : α
a✝ : β
⊢ motive (Quotient.mk s₁ a✝¹) (Quotient.mk s₂ a✝) q₃

tactic: apply h
state_before: case a.a.a
a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
s₃ : Setoid φ
motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop
h : ∀ (a : α) (b : β) (c : φ), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c)
a✝² : α
a✝¹ : β
a✝ : φ
⊢ motive (Quotient.mk s₁ a✝²) (Quotient.mk s₂ a✝¹) (Quotient.mk s₃ a✝)
Theorem: ProjectiveSpectrum.basicOpen_mul_le_left
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: rw [basicOpen_mul 𝒜 f g]
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 (f * g) ≤ basicOpen 𝒜 f

tactic: exact inf_le_left
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 f ⊓ basicOpen 𝒜 g ≤ basicOpen 𝒜 f
Theorem: ChartedSpace.liftPropAt_iff
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rw [LiftPropAt, LiftPropWithinAt, continuousWithinAt_univ, preimage_univ]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.8629
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
P : (H → H') → Set H → H → Prop
f : M → M'
x : M
⊢ LiftPropAt P f x ↔
    ContinuousAt f x ∧ P (↑(chartAt H' (f x)) ∘ f ∘ ↑(LocalHomeomorph.symm (chartAt H x))) univ (↑(chartAt H x) x)
Theorem: Nat.totient_mul
File: Mathlib/Data/Nat/Totient.lean

tactic: cases' Nat.mul_eq_zero.1 hmn0 with h h <;>
  simp only [totient_zero, MulZeroClass.mul_zero, MulZeroClass.zero_mul, h]
state_before: m n : ℕ
h : coprime m n
hmn0 : m * n = 0
⊢ φ (m * n) = φ m * φ n

tactic: haveI : NeZero (m * n) := ⟨hmn0⟩
state_before: m n : ℕ
h : coprime m n
hmn0 : ¬m * n = 0
⊢ φ (m * n) = φ m * φ n

tactic: haveI : NeZero m := ⟨left_ne_zero_of_mul hmn0⟩
state_before: m n : ℕ
h : coprime m n
hmn0 : ¬m * n = 0
this : NeZero (m * n)
⊢ φ (m * n) = φ m * φ n

tactic: haveI : NeZero n := ⟨right_ne_zero_of_mul hmn0⟩
state_before: m n : ℕ
h : coprime m n
hmn0 : ¬m * n = 0
this✝ : NeZero (m * n)
this : NeZero m
⊢ φ (m * n) = φ m * φ n

tactic: simp only [← ZMod.card_units_eq_totient]
state_before: m n : ℕ
h : coprime m n
hmn0 : ¬m * n = 0
this✝¹ : NeZero (m * n)
this✝ : NeZero m
this : NeZero n
⊢ φ (m * n) = φ m * φ n

tactic: rw [Fintype.card_congr (Units.mapEquiv (ZMod.chineseRemainder h).toMulEquiv).toEquiv,
  Fintype.card_congr (@MulEquiv.prodUnits (ZMod m) (ZMod n) _ _).toEquiv, Fintype.card_prod]
state_before: m n : ℕ
h : coprime m n
hmn0 : ¬m * n = 0
this✝¹ : NeZero (m * n)
this✝ : NeZero m
this : NeZero n
⊢ Fintype.card (ZMod (m * n))ˣ = Fintype.card (ZMod m)ˣ * Fintype.card (ZMod n)ˣ
Theorem: MeasureTheory.Measure.add_haar_sphere_of_ne_zero
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rcases hr.lt_or_lt with (h | h)
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.2016559
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
x : E
r : ℝ
hr : r ≠ 0
⊢ ↑↑μ (sphere x r) = 0

tactic: simp only [empty_diff, measure_empty, ← closedBall_diff_ball, closedBall_eq_empty.2 h]
state_before: case inl
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.2016559
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
x : E
r : ℝ
hr : r ≠ 0
h : r < 0
⊢ ↑↑μ (sphere x r) = 0

tactic: rw [← closedBall_diff_ball,
    measure_diff ball_subset_closedBall measurableSet_ball measure_ball_lt_top.ne,
    add_haar_ball_of_pos μ _ h, add_haar_closedBall μ _ h.le, tsub_self]
state_before: case inr
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.2016559
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
x : E
r : ℝ
hr : r ≠ 0
h : 0 < r
⊢ ↑↑μ (sphere x r) = 0
Theorem: List.filter_congr'
File: Std/Data/List/Lemmas.lean

tactic: rw [forall_mem_cons] at h
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
h : ∀ (x : α), x ∈ a :: l → (p x = true ↔ q x = true)
⊢ filter p (a :: l) = filter q (a :: l)

tactic: by_cases pa : p a
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true)
⊢ filter p (a :: l) = filter q (a :: l)

tactic: simp [pa, h.1.1 pa, filter_congr' h.2]
state_before: case pos
α : Type u_1
p q : α → Bool
a : α
l : List α
h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true)
pa : p a = true
⊢ filter p (a :: l) = filter q (a :: l)

tactic: simp [pa, mt h.1.2 pa, filter_congr' h.2]
state_before: case neg
α : Type u_1
p q : α → Bool
a : α
l : List α
h : (p a = true ↔ q a = true) ∧ ∀ (x : α), x ∈ l → (p x = true ↔ q x = true)
pa : ¬p a = true
⊢ filter p (a :: l) = filter q (a :: l)
Theorem: commutator_eq_closure
File: Mathlib/GroupTheory/Abelianization.lean

tactic: simp [commutator, Subgroup.commutator_def, commutatorSet]
state_before: G : Type u
inst✝ : Group G
⊢ commutator G = Subgroup.closure (commutatorSet G)
Theorem: MeasureTheory.integral_univ
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [Measure.restrict_univ]
state_before: α : Type u_2
β : Type ?u.33095
E : Type u_1
F : Type ?u.33101
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
⊢ (∫ (x : α) in univ, f x ∂μ) = ∫ (x : α), f x ∂μ
Theorem: StructureGroupoid.LocalInvariantProp.liftProp_id
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: simp_rw [liftProp_iff, continuous_id, true_and_iff]
state_before: H : Type u_1
M : Type u_2
H' : Type ?u.64061
M' : Type ?u.64064
X : Type ?u.64067
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG✝ : LocalInvariantProp G G' P
hG : LocalInvariantProp G G Q
hQ : ∀ (y : H), Q id univ y
⊢ LiftProp Q id

tactic: exact fun x ↦ hG.congr' ((chartAt H x).eventually_right_inverse <| mem_chart_target H x) (hQ _)
state_before: H : Type u_1
M : Type u_2
H' : Type ?u.64061
M' : Type ?u.64064
X : Type ?u.64067
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG✝ : LocalInvariantProp G G' P
hG : LocalInvariantProp G G Q
hQ : ∀ (y : H), Q id univ y
⊢ ∀ (x : M), Q (↑(chartAt H (id x)) ∘ id ∘ ↑(LocalHomeomorph.symm (chartAt H x))) univ (↑(chartAt H x) x)
Theorem: ClusterPt.of_nhds_le
File: Mathlib/Topology/Basic.lean

tactic: simp only [ClusterPt, inf_eq_left.mpr H, nhds_neBot]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
f : Filter α
H : 𝓝 x ≤ f
⊢ ClusterPt x f
Theorem: Real.abs_rpow_le_abs_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: cases' le_or_lt 0 x with hx hx
state_before: x y : ℝ
⊢ abs (x ^ y) ≤ abs x ^ y

tactic: rw [abs_rpow_of_nonneg hx]
state_before: case inl
x y : ℝ
hx : 0 ≤ x
⊢ abs (x ^ y) ≤ abs x ^ y

tactic: rw [abs_of_neg hx, rpow_def_of_neg hx, rpow_def_of_pos (neg_pos.2 hx), log_neg_eq_log, abs_mul,
  abs_of_pos (exp_pos _)]
state_before: case inr
x y : ℝ
hx : x < 0
⊢ abs (x ^ y) ≤ abs x ^ y

tactic: exact mul_le_of_le_one_right (exp_pos _).le (abs_cos_le_one _)
state_before: case inr
x y : ℝ
hx : x < 0
⊢ exp (log x * y) * abs (cos (y * π)) ≤ exp (log x * y)
Theorem: dvd_zero
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

tactic: simp
state_before: α : Type u_1
inst✝ : SemigroupWithZero α
a✝ a : α
⊢ a * 0 = 0
Theorem: Nat.div_eq_of_eq_mul_right
File: Std/Data/Nat/Lemmas.lean

tactic: rw [H2, Nat.mul_div_cancel_left _ H1]
state_before: n m k : Nat
H1 : 0 < n
H2 : m = n * k
⊢ m / n = k
Theorem: CategoryTheory.StrongMono.iff_of_arrow_iso
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

tactic: constructor <;> intro
state_before: C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
⊢ StrongMono f ↔ StrongMono g

tactic: exacts [StrongMono.of_arrow_iso e, StrongMono.of_arrow_iso e.symm]
state_before: case mp
C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
a✝ : StrongMono f
⊢ StrongMono g

case mpr
C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
a✝ : StrongMono g
⊢ StrongMono f
Theorem: SimpleGraph.incMatrix_mul_transpose_apply_of_adj
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: classical
  simp_rw [Matrix.mul_apply, Matrix.transpose_apply, incMatrix_apply_mul_incMatrix_apply,
    Set.indicator_apply, Pi.one_apply, sum_boole]
  convert @Nat.cast_one R _
  convert card_singleton ⟦(a, b)⟧
  rw [← coe_eq_singleton, coe_filter_univ]
  exact G.incidenceSet_inter_incidenceSet_of_adj h
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype (Sym2 α)
inst✝ : Semiring R
a b : α
e : Sym2 α
h : Adj G a b
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a b = 1

tactic: simp_rw [Matrix.mul_apply, Matrix.transpose_apply, incMatrix_apply_mul_incMatrix_apply,
  Set.indicator_apply, Pi.one_apply, sum_boole]
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype (Sym2 α)
inst✝ : Semiring R
a b : α
e : Sym2 α
h : Adj G a b
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a b = 1

tactic: convert @Nat.cast_one R _
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype (Sym2 α)
inst✝ : Semiring R
a b : α
e : Sym2 α
h : Adj G a b
⊢ ↑(card (filter (fun x => x ∈ incidenceSet G a ∩ incidenceSet G b) univ)) = 1

tactic: convert card_singleton ⟦(a, b)⟧
state_before: case h.e'_2.h.e'_3
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype (Sym2 α)
inst✝ : Semiring R
a b : α
e : Sym2 α
h : Adj G a b
⊢ card (filter (fun x => x ∈ incidenceSet G a ∩ incidenceSet G b) univ) = 1

tactic: rw [← coe_eq_singleton, coe_filter_univ]
state_before: case h.e'_2.h.e'_2.h
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype (Sym2 α)
inst✝ : Semiring R
a b : α
e : Sym2 α
h : Adj G a b
e_1✝ : Sym2 α = Quotient (Rel.setoid α)
⊢ filter (fun x => x ∈ incidenceSet G a ∩ incidenceSet G b) univ = {Quotient.mk (Rel.setoid α) (a, b)}

tactic: exact G.incidenceSet_inter_incidenceSet_of_adj h
state_before: case h.e'_2.h.e'_2.h
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype (Sym2 α)
inst✝ : Semiring R
a b : α
e : Sym2 α
h : Adj G a b
e_1✝ : Sym2 α = Quotient (Rel.setoid α)
⊢ {x | x ∈ incidenceSet G a ∩ incidenceSet G b} = {Quotient.mk (Rel.setoid α) (a, b)}
Theorem: MeasureTheory.Conservative.ae_mem_imp_frequently_image_mem
File: Mathlib/Dynamics/Ergodic/Conservative.lean

tactic: simp only [frequently_atTop, @forall_swap (_ ∈ s), ae_all_iff]
state_before: ι : Type ?u.63965
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
⊢ ∀ᵐ (x : α) ∂μ, x ∈ s → ∃ᶠ (n : ℕ) in atTop, (f^[n]) x ∈ s

tactic: intro n
state_before: ι : Type ?u.63965
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
⊢ ∀ (i : ℕ), ∀ᵐ (a : α) ∂μ, a ∈ s → ∃ b, b ≥ i ∧ (f^[b]) a ∈ s

tactic: filter_upwards [measure_zero_iff_ae_nmem.1 (hf.measure_mem_forall_ge_image_not_mem_eq_zero hs n)]
state_before: ι : Type ?u.63965
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
n : ℕ
⊢ ∀ᵐ (a : α) ∂μ, a ∈ s → ∃ b, b ≥ n ∧ (f^[b]) a ∈ s

tactic: simp
state_before: case h
ι : Type ?u.63965
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
n : ℕ
⊢ ∀ (a : α), ¬(a ∈ s ∧ ∀ (m : ℕ), m ≥ n → ¬(f^[m]) a ∈ s) → a ∈ s → ∃ b, b ≥ n ∧ (f^[b]) a ∈ s
Theorem: CategoryTheory.Limits.imageSubobject_le_mk
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [w]
state_before: C : Type u
inst✝³ : Category C
X✝ Y Z : C
f✝ : X✝ ⟶ Y
inst✝² : HasImage f✝
A B X : C
g : X ⟶ B
inst✝¹ : Mono g
f : A ⟶ B
inst✝ : HasImage f
h : A ⟶ X
w : h ≫ g = f
⊢ (h ≫ (underlyingIso g).inv) ≫ arrow (Subobject.mk g) = f
Theorem: Finset.affineCombinationLineMapWeights_apply_left
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [affineCombinationLineMapWeights, h.symm, sub_eq_neg_add]
state_before: k : Type u_2
V : Type ?u.434463
P : Type ?u.434466
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.435122
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
h : i ≠ j
c : k
⊢ affineCombinationLineMapWeights i j c i = 1 - c
Theorem: gauge_le_one_of_mem
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: rwa [one_smul]
state_before: 𝕜 : Type ?u.74283
E : Type u_1
F : Type ?u.74289
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
hx : x ∈ s
⊢ x ∈ 1 • s
Theorem: div_mul_cancel'''
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← inv_div, mul_div_cancel'']
state_before: α : Type ?u.57736
β : Type ?u.57739
G : Type u_1
inst✝ : Group G
a✝ b✝ c d a b : G
⊢ a / (b * a) = b⁻¹