tasksource/leandojo huggingface dataset:
Theorem: Module.Baer.extensionOfMax_le
File: Mathlib/Algebra/Module/Injective.lean

tactic: symm
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
x : { x // x ∈ (extensionOfMax i f).toLinearPMap.domain }
x' : { x // x ∈ (extensionOfMaxAdjoin i f h y).toLinearPMap.domain }
EQ : ↑x = ↑x'
⊢ ↑(extensionOfMax i f).toLinearPMap x = ↑(extensionOfMaxAdjoin i f h y).toLinearPMap x'

tactic: change ExtensionOfMaxAdjoin.extensionToFun i f h _ = _
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
x : { x // x ∈ (extensionOfMax i f).toLinearPMap.domain }
x' : { x // x ∈ (extensionOfMaxAdjoin i f h y).toLinearPMap.domain }
EQ : ↑x = ↑x'
⊢ ↑(extensionOfMaxAdjoin i f h y).toLinearPMap x' = ↑(extensionOfMax i f).toLinearPMap x

tactic: rw [ExtensionOfMaxAdjoin.extensionToFun_wd i f h x' x 0 (by simp [EQ]), map_zero,
  add_zero]
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
x : { x // x ∈ (extensionOfMax i f).toLinearPMap.domain }
x' : { x // x ∈ (extensionOfMaxAdjoin i f h y).toLinearPMap.domain }
EQ : ↑x = ↑x'
⊢ ExtensionOfMaxAdjoin.extensionToFun i f h x' = ↑(extensionOfMax i f).toLinearPMap x

tactic: simp [EQ]
state_before: R : Type u
inst✝⁷ : Ring R
Q : TypeMax
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R Q
M N : Type (max u v)
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
inst✝ : Fact (Function.Injective ↑i)
h : Baer R Q
y : N
x : { x // x ∈ (extensionOfMax i f).toLinearPMap.domain }
x' : { x // x ∈ (extensionOfMaxAdjoin i f h y).toLinearPMap.domain }
EQ : ↑x = ↑x'
⊢ ↑x' = ↑x + 0 • y
Theorem: EuclideanGeometry.Cospherical.affineIndependent_of_mem_of_ne
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: refine' hs.affineIndependent _ _
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
hs : Cospherical s
p₁ p₂ p₃ : P
h₁ : p₁ ∈ s
h₂ : p₂ ∈ s
h₃ : p₃ ∈ s
h₁₂ : p₁ ≠ p₂
h₁₃ : p₁ ≠ p₃
h₂₃ : p₂ ≠ p₃
⊢ AffineIndependent ℝ ![p₁, p₂, p₃]

tactic: simp [h₁, h₂, h₃, Set.insert_subset]
state_before: case refine'_1
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
hs : Cospherical s
p₁ p₂ p₃ : P
h₁ : p₁ ∈ s
h₂ : p₂ ∈ s
h₃ : p₃ ∈ s
h₁₂ : p₁ ≠ p₂
h₁₃ : p₁ ≠ p₃
h₂₃ : p₂ ≠ p₃
⊢ Set.range ![p₁, p₂, p₃] ⊆ s

tactic: erw [Fin.cons_injective_iff, Fin.cons_injective_iff]
state_before: case refine'_2
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
hs : Cospherical s
p₁ p₂ p₃ : P
h₁ : p₁ ∈ s
h₂ : p₂ ∈ s
h₃ : p₃ ∈ s
h₁₂ : p₁ ≠ p₂
h₁₃ : p₁ ≠ p₃
h₂₃ : p₂ ≠ p₃
⊢ Function.Injective ![p₁, p₂, p₃]

tactic: simp [h₁₂, h₁₃, h₂₃, Function.Injective]
state_before: case refine'_2
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
hs : Cospherical s
p₁ p₂ p₃ : P
h₁ : p₁ ∈ s
h₂ : p₂ ∈ s
h₃ : p₃ ∈ s
h₁₂ : p₁ ≠ p₂
h₁₃ : p₁ ≠ p₃
h₂₃ : p₂ ≠ p₃
⊢ ¬p₁ ∈ Set.range ![p₂, p₃] ∧ ¬p₂ ∈ Set.range ![p₃] ∧ Function.Injective ![p₃]
Theorem: SimpleGraph.left_nonuniformWitnesses_subset
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: rw [nonuniformWitnesses, dif_pos h]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
⊢ (nonuniformWitnesses G ε s t).fst ⊆ s

tactic: exact (not_isUniform_iff.1 h).choose_spec.1
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
h : ¬IsUniform G ε s t
⊢ (Exists.choose
          (_ :
            ∃ s',
              s' ⊆ s ∧
                ∃ t',
                  t' ⊆ t ∧
                    ↑(card s) * ε ≤ ↑(card s') ∧
                      ↑(card t) * ε ≤ ↑(card t') ∧ ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))),
        Exists.choose
          (_ :
            ∃ t',
              t' ⊆ t ∧
                ↑(card s) * ε ≤
                    ↑(card
                        (Exists.choose
                          (_ :
                            ∃ s',
                              s' ⊆ s ∧
                                ∃ t',
                                  t' ⊆ t ∧
                                    ↑(card s) * ε ≤ ↑(card s') ∧
                                      ↑(card t) * ε ≤ ↑(card t') ∧
                                        ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))))) ∧
                  ↑(card t) * ε ≤ ↑(card t') ∧
                    ε ≤
                      ↑(abs
                          (edgeDensity G
                              (Exists.choose
                                (_ :
                                  ∃ s',
                                    s' ⊆ s ∧
                                      ∃ t',
                                        t' ⊆ t ∧
                                          ↑(card s) * ε ≤ ↑(card s') ∧
                                            ↑(card t) * ε ≤ ↑(card t') ∧
                                              ε ≤ ↑(abs (edgeDensity G s' t' - edgeDensity G s t))))
                              t' -
                            edgeDensity G s t)))).fst ⊆
    s
Theorem: Con.ext
File: Mathlib/GroupTheory/Congruence.lean

tactic: ext
state_before: M : Type u_1
N : Type ?u.7026
P : Type ?u.7029
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
H : ∀ (x y : M), ↑c x y ↔ ↑d x y
⊢ r = r

tactic: apply H
state_before: case h.h.a
M : Type u_1
N : Type ?u.7026
P : Type ?u.7029
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
H : ∀ (x y : M), ↑c x y ↔ ↑d x y
x✝¹ x✝ : M
⊢ r x✝¹ x✝ ↔ r x✝¹ x✝
Theorem: Int.mul_assoc
File: Std/Data/Int/Lemmas.lean

tactic: cases a <;> cases b <;> cases c <;> simp [Nat.mul_assoc]
state_before: a b c : Int
⊢ a * b * c = a * (b * c)
Theorem: norm_expSeries_summable_of_mem_ball'
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: change Summable (norm ∘ _)
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
𝔹 : Type ?u.75852
inst✝⁴ : NontriviallyNormedField 𝕂
inst✝³ : NormedRing 𝔸
inst✝² : NormedRing 𝔹
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : NormedAlgebra 𝕂 𝔹
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ Summable fun n => ‖(↑n !)⁻¹ • x ^ n‖

tactic: rw [← expSeries_apply_eq']
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
𝔹 : Type ?u.75852
inst✝⁴ : NontriviallyNormedField 𝕂
inst✝³ : NormedRing 𝔸
inst✝² : NormedRing 𝔹
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : NormedAlgebra 𝕂 𝔹
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ Summable (norm ∘ fun n => (↑n !)⁻¹ • x ^ n)

tactic: exact norm_expSeries_summable_of_mem_ball x hx
state_before: 𝕂 : Type u_2
𝔸 : Type u_1
𝔹 : Type ?u.75852
inst✝⁴ : NontriviallyNormedField 𝕂
inst✝³ : NormedRing 𝔸
inst✝² : NormedRing 𝔹
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : NormedAlgebra 𝕂 𝔹
x : 𝔸
hx : x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ Summable (norm ∘ fun n => ↑(expSeries 𝕂 𝔸 n) fun x_1 => x)
Theorem: even_iff_two_dvd
File: Mathlib/Algebra/Parity.lean

tactic: simp [Even, Dvd.dvd, two_mul]
state_before: F : Type ?u.63447
α : Type u_1
β : Type ?u.63453
R : Type ?u.63456
inst✝¹ : Semiring α
inst✝ : Semiring β
m n a : α
⊢ Even a ↔ 2 ∣ a
Theorem: Finset.gcd_mul_left
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: refine' s.induction_on _ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.34528
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (gcd s fun x => a * f x) = ↑normalize a * gcd s f

tactic: simp
state_before: case refine'_1
α : Type u_1
β : Type u_2
γ : Type ?u.34528
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (gcd ∅ fun x => a * f x) = ↑normalize a * gcd ∅ f

tactic: intro b t _ h
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.34528
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ ∀ ⦃a_1 : β⦄ {s : Finset β},
    ¬a_1 ∈ s →
      (gcd s fun x => a * f x) = ↑normalize a * gcd s f →
        (gcd (insert a_1 s) fun x => a * f x) = ↑normalize a * gcd (insert a_1 s) f

tactic: rw [gcd_insert, gcd_insert, h, ← gcd_mul_left]
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.34528
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : ¬b ∈ t
h : (gcd t fun x => a * f x) = ↑normalize a * gcd t f
⊢ (gcd (insert b t) fun x => a * f x) = ↑normalize a * gcd (insert b t) f

tactic: apply ((normalize_associated a).mul_right _).gcd_eq_right
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.34528
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : ¬b ∈ t
h : (gcd t fun x => a * f x) = ↑normalize a * gcd t f
⊢ GCDMonoid.gcd (a * f b) (↑normalize a * gcd t f) = GCDMonoid.gcd (a * f b) (a * gcd t f)
Theorem: sup_biSup
File: Mathlib/Order/CompleteLattice.lean

tactic: simpa only [sup_comm] using @biSup_sup α _ _ p _ _ h
state_before: α : Type u_2
β : Type ?u.103547
β₂ : Type ?u.103550
γ : Type ?u.103553
ι : Sort u_1
ι' : Sort ?u.103559
κ : ι → Sort ?u.103564
κ' : ι' → Sort ?u.103569
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
⊢ (a ⊔ ⨆ (i : ι) (h : p i), f i h) = ⨆ (i : ι) (h : p i), a ⊔ f i h
Theorem: List.replicateTR_loop_eq
File: Std/Data/List/Basic.lean

tactic: rw [← replicateTR_loop_replicate_eq _ 1 n, replicate, replicate,
replicateTR.loop, replicateTR_loop_eq n, replicateTR_loop_eq n, append_assoc]
state_before: α✝ : Type u_1
a : α✝
acc : List α✝
n : Nat
⊢ replicateTR.loop a (n + 1) acc = replicate (n + 1) a ++ acc

tactic: rfl
state_before: α✝ : Type u_1
a : α✝
acc : List α✝
n : Nat
⊢ replicate n a ++ a :: acc = replicate n a ++ ([a] ++ acc)
Theorem: MeasureTheory.integrableOn_iUnion_of_summable_norm_restrict
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: refine'
  integrableOn_iUnion_of_summable_integral_norm (fun i => (s i).isCompact.isClosed.measurableSet)
    (fun i => (map_continuous f).continuousOn.integrableOn_compact (s i).isCompact)
    (summable_of_nonneg_of_le (fun ι => integral_nonneg fun x => norm_nonneg _) (fun i => _) hf)
state_before: α : Type u_1
β : Type u_3
E : Type u_2
F : Type ?u.308351
inst✝⁶ : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : Countable β
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : MetrizableSpace α
inst✝ : IsLocallyFiniteMeasure μ
f : C(α, E)
s : β → Compacts α
hf : Summable fun i => ‖ContinuousMap.restrict (↑(s i)) f‖ * ENNReal.toReal (↑↑μ ↑(s i))
⊢ IntegrableOn (↑f) (⋃ (i : β), ↑(s i))

tactic: rw [← (Real.norm_of_nonneg (integral_nonneg fun a => norm_nonneg _) : ‖_‖ = ∫ x in s i, ‖f x‖ ∂μ)]
state_before: α : Type u_1
β : Type u_3
E : Type u_2
F : Type ?u.308351
inst✝⁶ : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : Countable β
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : MetrizableSpace α
inst✝ : IsLocallyFiniteMeasure μ
f : C(α, E)
s : β → Compacts α
hf : Summable fun i => ‖ContinuousMap.restrict (↑(s i)) f‖ * ENNReal.toReal (↑↑μ ↑(s i))
i : β
⊢ (∫ (a : α) in ↑(s i), ‖↑f a‖ ∂μ) ≤ ‖ContinuousMap.restrict (↑(s i)) f‖ * ENNReal.toReal (↑↑μ ↑(s i))

tactic: exact
  norm_set_integral_le_of_norm_le_const' (s i).isCompact.measure_lt_top
    (s i).isCompact.isClosed.measurableSet fun x hx =>
    (norm_norm (f x)).symm ▸ (f.restrict (s i : Set α)).norm_coe_le_norm ⟨x, hx⟩
state_before: α : Type u_1
β : Type u_3
E : Type u_2
F : Type ?u.308351
inst✝⁶ : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : Countable β
inst✝³ : TopologicalSpace α
inst✝² : BorelSpace α
inst✝¹ : MetrizableSpace α
inst✝ : IsLocallyFiniteMeasure μ
f : C(α, E)
s : β → Compacts α
hf : Summable fun i => ‖ContinuousMap.restrict (↑(s i)) f‖ * ENNReal.toReal (↑↑μ ↑(s i))
i : β
⊢ ‖∫ (x : α) in ↑(s i), ‖↑f x‖ ∂μ‖ ≤ ‖ContinuousMap.restrict (↑(s i)) f‖ * ENNReal.toReal (↑↑μ ↑(s i))
Theorem: AddCommGroup.modEq_refl
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a✝ a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
a : α
⊢ a - a = 0 • p
Theorem: Int.natAbs_pow
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: induction' k with k ih <;> [rfl; rw [pow_succ', Int.natAbs_mul, pow_succ', ih]]
state_before: α : Type ?u.267830
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
n : ℤ
k : ℕ
⊢ natAbs (n ^ k) = natAbs n ^ k
Theorem: Finsupp.some_single_some
File: Mathlib/Data/Finsupp/Basic.lean

tactic: classical
  ext b
  simp [single_apply]
state_before: α : Type u_2
β : Type ?u.325058
γ : Type ?u.325061
ι : Type ?u.325064
M : Type u_1
M' : Type ?u.325070
N : Type ?u.325073
P : Type ?u.325076
G : Type ?u.325079
H : Type ?u.325082
R : Type ?u.325085
S : Type ?u.325088
inst✝ : Zero M
a : α
m : M
⊢ some (single (Option.some a) m) = single a m

tactic: ext b
state_before: α : Type u_2
β : Type ?u.325058
γ : Type ?u.325061
ι : Type ?u.325064
M : Type u_1
M' : Type ?u.325070
N : Type ?u.325073
P : Type ?u.325076
G : Type ?u.325079
H : Type ?u.325082
R : Type ?u.325085
S : Type ?u.325088
inst✝ : Zero M
a : α
m : M
⊢ some (single (Option.some a) m) = single a m

tactic: simp [single_apply]
state_before: case h
α : Type u_2
β : Type ?u.325058
γ : Type ?u.325061
ι : Type ?u.325064
M : Type u_1
M' : Type ?u.325070
N : Type ?u.325073
P : Type ?u.325076
G : Type ?u.325079
H : Type ?u.325082
R : Type ?u.325085
S : Type ?u.325088
inst✝ : Zero M
a : α
m : M
b : α
⊢ ↑(some (single (Option.some a) m)) b = ↑(single a m) b
Theorem: Pi.mulSingle_apply_commute
File: Mathlib/Algebra/Group/Pi.lean

tactic: obtain rfl | hij := Decidable.eq_or_ne i j
state_before: ι : Type ?u.74703
α : Type ?u.74706
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i j : I
⊢ Commute (mulSingle i (x i)) (mulSingle j (x j))

tactic: rfl
state_before: case inl
ι : Type ?u.74703
α : Type ?u.74706
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i : I
⊢ Commute (mulSingle i (x i)) (mulSingle i (x i))

tactic: exact Pi.mulSingle_commute hij _ _
state_before: case inr
ι : Type ?u.74703
α : Type ?u.74706
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i j : I
hij : i ≠ j
⊢ Commute (mulSingle i (x i)) (mulSingle j (x j))
Theorem: MeasureTheory.measure_eq_measure_of_between_null_diff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: have le12 : μ s₁ ≤ μ s₂ := measure_mono h12
state_before: α : Type u_1
β : Type ?u.27550
γ : Type ?u.27553
δ : Type ?u.27556
ι : Type ?u.27559
R : Type ?u.27562
R' : Type ?u.27565
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁✝ s₂✝ t s₁ s₂ s₃ : Set α
h12 : s₁ ⊆ s₂
h23 : s₂ ⊆ s₃
h_nulldiff : ↑↑μ (s₃ \ s₁) = 0
⊢ ↑↑μ s₁ = ↑↑μ s₂ ∧ ↑↑μ s₂ = ↑↑μ s₃

tactic: have le23 : μ s₂ ≤ μ s₃ := measure_mono h23
state_before: α : Type u_1
β : Type ?u.27550
γ : Type ?u.27553
δ : Type ?u.27556
ι : Type ?u.27559
R : Type ?u.27562
R' : Type ?u.27565
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁✝ s₂✝ t s₁ s₂ s₃ : Set α
h12 : s₁ ⊆ s₂
h23 : s₂ ⊆ s₃
h_nulldiff : ↑↑μ (s₃ \ s₁) = 0
le12 : ↑↑μ s₁ ≤ ↑↑μ s₂
⊢ ↑↑μ s₁ = ↑↑μ s₂ ∧ ↑↑μ s₂ = ↑↑μ s₃

tactic: have key : μ s₃ ≤ μ s₁ :=
  calc
    μ s₃ = μ (s₃ \ s₁ ∪ s₁) := by rw [diff_union_of_subset (h12.trans h23)]
    _ ≤ μ (s₃ \ s₁) + μ s₁ := (measure_union_le _ _)
    _ = μ s₁ := by simp only [h_nulldiff, zero_add]
state_before: α : Type u_1
β : Type ?u.27550
γ : Type ?u.27553
δ : Type ?u.27556
ι : Type ?u.27559
R : Type ?u.27562
R' : Type ?u.27565
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁✝ s₂✝ t s₁ s₂ s₃ : Set α
h12 : s₁ ⊆ s₂
h23 : s₂ ⊆ s₃
h_nulldiff : ↑↑μ (s₃ \ s₁) = 0
le12 : ↑↑μ s₁ ≤ ↑↑μ s₂
le23 : ↑↑μ s₂ ≤ ↑↑μ s₃
⊢ ↑↑μ s₁ = ↑↑μ s₂ ∧ ↑↑μ s₂ = ↑↑μ s₃

tactic: exact ⟨le12.antisymm (le23.trans key), le23.antisymm (key.trans le12)⟩
state_before: α : Type u_1
β : Type ?u.27550
γ : Type ?u.27553
δ : Type ?u.27556
ι : Type ?u.27559
R : Type ?u.27562
R' : Type ?u.27565
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁✝ s₂✝ t s₁ s₂ s₃ : Set α
h12 : s₁ ⊆ s₂
h23 : s₂ ⊆ s₃
h_nulldiff : ↑↑μ (s₃ \ s₁) = 0
le12 : ↑↑μ s₁ ≤ ↑↑μ s₂
le23 : ↑↑μ s₂ ≤ ↑↑μ s₃
key : ↑↑μ s₃ ≤ ↑↑μ s₁
⊢ ↑↑μ s₁ = ↑↑μ s₂ ∧ ↑↑μ s₂ = ↑↑μ s₃

tactic: rw [diff_union_of_subset (h12.trans h23)]
state_before: α : Type u_1
β : Type ?u.27550
γ : Type ?u.27553
δ : Type ?u.27556
ι : Type ?u.27559
R : Type ?u.27562
R' : Type ?u.27565
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁✝ s₂✝ t s₁ s₂ s₃ : Set α
h12 : s₁ ⊆ s₂
h23 : s₂ ⊆ s₃
h_nulldiff : ↑↑μ (s₃ \ s₁) = 0
le12 : ↑↑μ s₁ ≤ ↑↑μ s₂
le23 : ↑↑μ s₂ ≤ ↑↑μ s₃
⊢ ↑↑μ s₃ = ↑↑μ (s₃ \ s₁ ∪ s₁)

tactic: simp only [h_nulldiff, zero_add]
state_before: α : Type u_1
β : Type ?u.27550
γ : Type ?u.27553
δ : Type ?u.27556
ι : Type ?u.27559
R : Type ?u.27562
R' : Type ?u.27565
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁✝ s₂✝ t s₁ s₂ s₃ : Set α
h12 : s₁ ⊆ s₂
h23 : s₂ ⊆ s₃
h_nulldiff : ↑↑μ (s₃ \ s₁) = 0
le12 : ↑↑μ s₁ ≤ ↑↑μ s₂
le23 : ↑↑μ s₂ ≤ ↑↑μ s₃
⊢ ↑↑μ (s₃ \ s₁) + ↑↑μ s₁ = ↑↑μ s₁
Theorem: ENNReal.rpow_pos_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: by_cases hp_zero : p = 0
state_before: p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hp_nonneg : 0 ≤ p
⊢ 0 < x ^ p

tactic: simp [hp_zero, zero_lt_one]
state_before: case pos
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hp_nonneg : 0 ≤ p
hp_zero : p = 0
⊢ 0 < x ^ p

tactic: rw [← Ne.def] at hp_zero
state_before: case neg
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hp_nonneg : 0 ≤ p
hp_zero : ¬p = 0
⊢ 0 < x ^ p

tactic: have hp_pos := lt_of_le_of_ne hp_nonneg hp_zero.symm
state_before: case neg
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hp_nonneg : 0 ≤ p
hp_zero : p ≠ 0
⊢ 0 < x ^ p

tactic: rw [← zero_rpow_of_pos hp_pos]
state_before: case neg
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hp_nonneg : 0 ≤ p
hp_zero : p ≠ 0
hp_pos : 0 < p
⊢ 0 < x ^ p

tactic: exact rpow_lt_rpow hx_pos hp_pos
state_before: case neg
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hp_nonneg : 0 ≤ p
hp_zero : p ≠ 0
hp_pos : 0 < p
⊢ 0 ^ p < x ^ p
Theorem: Filter.HasBasis.limsup_eq_iInf_iSup
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [sSup_image, id]
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.109072
ι : Type u_2
inst✝ : CompleteLattice α
p : ι → Prop
s : ι → Set β
f : Filter β
u : β → α
h : HasBasis f p s
⊢ (⨅ (i : ι) (_ : p i), sSup (u '' s i)) = ⨅ (i : ι) (_ : p i), ⨆ (a : β) (_ : a ∈ s i), u a
Theorem: div_div_div_cancel_left
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← inv_div b c, div_inv_eq_mul, mul_comm, div_mul_div_cancel']
state_before: α : Type ?u.74626
β : Type ?u.74629
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ c / a / (c / b) = b / a
Theorem: closedBall_div_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall x δ / {y} = closedBall (x / y) δ
Theorem: sub_one_div_inv_le_two
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: refine' (inv_le_inv_of_le (inv_pos.2 <| zero_lt_two' α) _).trans_eq (inv_inv (2 : α))
state_before: ι : Type ?u.187185
α : Type u_1
β : Type ?u.187191
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ (1 - 1 / a)⁻¹ ≤ 2

tactic: rw [le_sub_iff_add_le, add_comm, ←le_sub_iff_add_le]
state_before: ι : Type ?u.187185
α : Type u_1
β : Type ?u.187191
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 2⁻¹ ≤ 1 - 1 / a

tactic: convert (one_div a).le.trans (inv_le_inv_of_le zero_lt_two a2) using 1
state_before: ι : Type ?u.187185
α : Type u_1
β : Type ?u.187191
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 1 / a ≤ 1 - 2⁻¹

tactic: rw [sub_eq_iff_eq_add, ←two_mul, mul_inv_cancel two_ne_zero]
state_before: case h.e'_4
ι : Type ?u.187185
α : Type u_1
β : Type ?u.187191
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a2 : 2 ≤ a
⊢ 1 - 2⁻¹ = 2⁻¹
Theorem: List.prev_ne_cons_cons
File: Mathlib/Data/List/Cycle.lean

tactic: simpa [hy] using h
state_before: α : Type ?u.86825
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hy : x ≠ y
hz : x ≠ z
⊢ x ∈ z :: l

tactic: cases l
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hy : x ≠ y
hz : x ≠ z
⊢ prev (y :: z :: l) x h = prev (z :: l) x (_ : x ∈ z :: l)

tactic: simp [hy, hz] at h
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x ≠ z
h : x ∈ [y, z]
⊢ prev [y, z] x h = prev [z] x (_ : x ∈ [z])

tactic: rw [prev, dif_neg hy, if_neg hz]
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x ≠ z
head✝ : α
tail✝ : List α
h : x ∈ y :: z :: head✝ :: tail✝
⊢ prev (y :: z :: head✝ :: tail✝) x h = prev (z :: head✝ :: tail✝) x (_ : x ∈ z :: head✝ :: tail✝)
Theorem: Mathlib.Tactic.Ring.add_overlap_pf
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b c x : R
e : ℕ
pq_pf : a + b = c
⊢ x ^ e * a + x ^ e * b = x ^ e * c

tactic: simp [mul_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b x : R
e : ℕ
⊢ x ^ e * a + x ^ e * b = x ^ e * (a + b)
Theorem: Complex.IsExpCmpFilter.isLittleO_im_pow_exp_re
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simp
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
⊢ ∀ (x : ℂ), ((fun z => z.im ^ ↑n) ^ 2) x = (x.im ^ ↑n) ^ 2

tactic: norm_cast
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
x✝ : ℂ
⊢ (x✝.im ^ ↑n) ^ 2 = x✝.im ^ (2 * ↑n)

tactic: rw [pow_mul']
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
x✝ : ℂ
⊢ (x✝.im ^ n) ^ 2 = x✝.im ^ (2 * n)

tactic: have := hl.isBigO_im_pow_re (2 * n)
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
⊢ (fun z => z.im ^ (2 * ↑n)) =O[l] fun z => Real.exp z.re

tactic: norm_cast at *
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
this : (fun z => z.im ^ ↑(2 * n)) =O[l] fun z => Real.exp z.re
⊢ (fun z => z.im ^ (2 * ↑n)) =O[l] fun z => Real.exp z.re

tactic: norm_cast
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
x✝ : ℂ
⊢ Real.exp x✝.re = Real.exp x✝.re ^ 1

tactic: rw [pow_one]
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
x✝ : ℂ
⊢ Real.exp x✝.re = Real.exp x✝.re ^ 1

tactic: have := (isLittleO_pow_pow_atTop_of_lt one_lt_two).comp_tendsto <|
  Real.tendsto_exp_atTop.comp hl.tendsto_re
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
⊢ (fun z => Real.exp z.re ^ 1) =o[l] fun z => Real.exp z.re ^ 2

tactic: simpa only [pow_one, Real.rpow_one, Real.rpow_two]
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
this : ((fun x => x ^ 1) ∘ Real.exp ∘ re) =o[l] ((fun x => x ^ 2) ∘ Real.exp ∘ re)
⊢ (fun z => Real.exp z.re ^ 1) =o[l] fun z => Real.exp z.re ^ 2

tactic: simp
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
⊢ ∀ (x : ℂ), Real.exp x.re ^ 2 = ((fun z => Real.exp z.re) ^ 2) x