tasksource/leandojo huggingface dataset:
Theorem: wbtw_self_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.153895
P : Type u_3
P' : Type ?u.153901
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
⊢ Wbtw R x y x ↔ y = x

tactic: have ⟨_, _, h₂⟩ := h
state_before: case refine'_1
R : Type u_1
V : Type u_2
V' : Type ?u.153895
P : Type u_3
P' : Type ?u.153901
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
h : Wbtw R x y x
⊢ y = x

tactic: rw [h₂.symm, lineMap_same_apply]
state_before: case refine'_1
R : Type u_1
V : Type u_2
V' : Type ?u.153895
P : Type u_3
P' : Type ?u.153901
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
h : Wbtw R x y x
w✝ : R
left✝ : w✝ ∈ Set.Icc 0 1
h₂ : ↑(lineMap x x) w✝ = y
⊢ y = x

tactic: rw [h]
state_before: case refine'_2
R : Type u_1
V : Type u_2
V' : Type ?u.153895
P : Type u_3
P' : Type ?u.153901
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
h : y = x
⊢ Wbtw R x y x

tactic: exact wbtw_self_left R x x
state_before: case refine'_2
R : Type u_1
V : Type u_2
V' : Type ?u.153895
P : Type u_3
P' : Type ?u.153901
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
h : y = x
⊢ Wbtw R x x x
Theorem: Orientation.map_refl
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: rw [Orientation.map, AlternatingMap.domLCongr_refl, Module.Ray.map_refl]
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type ?u.10058
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_3
⊢ map ι (LinearEquiv.refl R M) = Equiv.refl (Orientation R M ι)
Theorem: ModuleCat.MonoidalCategory.associator_naturality
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

tactic: convert associator_naturality_aux f₁ f₂ f₃ using 1
state_before: R : Type u
inst✝ : CommRing R
X₁ : ModuleCat R
X₂ : ModuleCat R
X₃ : ModuleCat R
Y₁ : ModuleCat R
Y₂ : ModuleCat R
Y₃ : ModuleCat R
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
⊢ tensorHom (tensorHom f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom =
    (associator X₁ X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃)
Theorem: Stream'.Seq.head_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: rw [head_eq_destruct, destruct_cons, Option.map_eq_map, Option.map_some']
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : Seq α
⊢ head (cons a s) = some a
Theorem: List.Ico.chain'_succ
File: Mathlib/Data/List/Intervals.lean

tactic: by_cases n < m
state_before: n m : ℕ
⊢ Chain' (fun a b => b = succ a) (Ico n m)

tactic: rw [eq_cons h]
state_before: case pos
n m : ℕ
h : n < m
⊢ Chain' (fun a b => b = succ a) (Ico n m)

tactic: exact chain_succ_range' _ _ 1
state_before: case pos
n m : ℕ
h : n < m
⊢ Chain' (fun a b => b = succ a) (n :: Ico (n + 1) m)

tactic: rw [eq_nil_of_le (le_of_not_gt h)]
state_before: case neg
n m : ℕ
h : ¬n < m
⊢ Chain' (fun a b => b = succ a) (Ico n m)

tactic: trivial
state_before: case neg
n m : ℕ
h : ¬n < m
⊢ Chain' (fun a b => b = succ a) []
Theorem: mul_eq_mul_iff_eq_and_eq_of_pos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rcases hac.eq_or_lt with (rfl | hac)
state_before: α : Type u_1
a b c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac : a ≤ b
hbd : c ≤ d
a0 : 0 < a
d0 : 0 < d
h : a * c = b * d
⊢ a = b ∧ c = d

tactic: rcases eq_or_lt_of_le hbd with (rfl | hbd)
state_before: case inr
α : Type u_1
a b c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac✝ : a ≤ b
hbd : c ≤ d
a0 : 0 < a
d0 : 0 < d
h : a * c = b * d
hac : a < b
⊢ a = b ∧ c = d

tactic: exact ((mul_lt_mul_of_pos_of_pos hac hbd a0 d0).ne h).elim
state_before: case inr.inr
α : Type u_1
a b c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac✝ : a ≤ b
hbd✝ : c ≤ d
a0 : 0 < a
d0 : 0 < d
h : a * c = b * d
hac : a < b
hbd : c < d
⊢ a = b ∧ c = d

tactic: exact ⟨rfl, (mul_left_cancel_iff_of_pos a0).mp h⟩
state_before: case inl
α : Type u_1
a c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hbd : c ≤ d
a0 : 0 < a
d0 : 0 < d
hac : a ≤ a
h : a * c = a * d
⊢ a = a ∧ c = d

tactic: exact ⟨(mul_right_cancel_iff_of_pos d0).mp h, rfl⟩
state_before: case inr.inl
α : Type u_1
a b c : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac✝ : a ≤ b
a0 : 0 < a
hac : a < b
hbd : c ≤ c
d0 : 0 < c
h : a * c = b * c
⊢ a = b ∧ c = c
Theorem: Metric.continuousAt_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [ContinuousAt, tendsto_nhds_nhds]
state_before: α : Type u
β : Type v
X : Type ?u.100766
ι : Type ?u.100769
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : PseudoMetricSpace β
f : α → β
a : α
⊢ ContinuousAt f a ↔ ∀ (ε : ℝ), ε > 0 → ∃ δ, δ > 0 ∧ ∀ {x : α}, dist x a < δ → dist (f x) (f a) < ε
Theorem: Nat.log_eq_one_iff'
File: Mathlib/Data/Nat/Log.lean

tactic: rw [log_eq_iff (Or.inl one_ne_zero), pow_add, pow_one]
state_before: b n : ℕ
⊢ log b n = 1 ↔ b ≤ n ∧ n < b * b
Theorem: CancelDenoms.sub_subst
File: Mathlib/Tactic/CancelDenoms.lean

tactic: simp [left_distrib, *, sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : Ring α
n e1 e2 t1 t2 : α
h1 : n * e1 = t1
h2 : n * e2 = t2
⊢ n * (e1 - e2) = t1 - t2
Theorem: MvPolynomial.eval_assoc
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [eval₂_comp_left (eval g)]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_2
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
τ : Type u_1
f : σ → MvPolynomial τ R
g : τ → R
p : MvPolynomial σ R
⊢ ↑(eval (↑(eval g) ∘ f)) p = ↑(eval g) (eval₂ C f p)

tactic: unfold eval
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_2
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
τ : Type u_1
f : σ → MvPolynomial τ R
g : τ → R
p : MvPolynomial σ R
⊢ ↑(eval (↑(eval g) ∘ f)) p = eval₂ (RingHom.comp (eval g) C) (↑(eval g) ∘ f) p

tactic: simp only [coe_eval₂Hom]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_2
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
τ : Type u_1
f : σ → MvPolynomial τ R
g : τ → R
p : MvPolynomial σ R
⊢ ↑(eval₂Hom (RingHom.id R) (↑(eval₂Hom (RingHom.id R) g) ∘ f)) p =
    eval₂ (RingHom.comp (eval₂Hom (RingHom.id R) g) C) (↑(eval₂Hom (RingHom.id R) g) ∘ f) p

tactic: congr with a
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_2
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
τ : Type u_1
f : σ → MvPolynomial τ R
g : τ → R
p : MvPolynomial σ R
⊢ eval₂ (RingHom.id R) (eval₂ (RingHom.id R) g ∘ f) p =
    eval₂ (RingHom.comp (eval₂Hom (RingHom.id R) g) C) (eval₂ (RingHom.id R) g ∘ f) p

tactic: simp
state_before: case e_f.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_2
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : σ → R
τ : Type u_1
f : σ → MvPolynomial τ R
g : τ → R
p : MvPolynomial σ R
a : R
⊢ ↑(RingHom.id R) a = ↑(RingHom.comp (eval₂Hom (RingHom.id R) g) C) a
Theorem: lp.norm_eq_ciSup
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: dsimp [norm]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
⊢ ‖f‖ = ⨆ (i : α), ‖↑f i‖

tactic: rw [dif_neg ENNReal.top_ne_zero, if_pos rfl]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
⊢ (if hp : ⊤ = 0 then
      Eq.rec (motive := fun x x_1 => { x_2 // x_2 ∈ lp E x } → ℝ)
        (fun f => ↑(Finset.card (Set.Finite.toFinset (_ : Set.Finite {i | ↑f i ≠ 0})))) (_ : 0 = ⊤) f
    else if ⊤ = ⊤ then ⨆ (i : α), ‖↑f i‖ else (∑' (i : α), ‖↑f i‖ ^ 0) ^ (1 / 0)) =
    ⨆ (i : α), ‖↑f i‖
Theorem: ENNReal.le_of_top_imp_top_of_toNNReal_le
File: Mathlib/Data/Real/ENNReal.lean

tactic: by_contra' hlt
state_before: α : Type ?u.142320
β : Type ?u.142323
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a = ⊤ → b = ⊤
h_nnreal : a ≠ ⊤ → b ≠ ⊤ → ENNReal.toNNReal a ≤ ENNReal.toNNReal b
⊢ a ≤ b

tactic: lift b to ℝ≥0 using hlt.ne_top
state_before: α : Type ?u.142320
β : Type ?u.142323
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a = ⊤ → b = ⊤
h_nnreal : a ≠ ⊤ → b ≠ ⊤ → ENNReal.toNNReal a ≤ ENNReal.toNNReal b
hlt : b < a
⊢ False

tactic: lift a to ℝ≥0 using mt h coe_ne_top
state_before: case intro
α : Type ?u.142320
β : Type ?u.142323
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
h : a = ⊤ → ↑b = ⊤
h_nnreal : a ≠ ⊤ → ↑b ≠ ⊤ → ENNReal.toNNReal a ≤ ENNReal.toNNReal ↑b
hlt : ↑b < a
⊢ False

tactic: refine hlt.not_le ?_
state_before: case intro.intro
α : Type ?u.142320
β : Type ?u.142323
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
h : ↑a = ⊤ → ↑b = ⊤
h_nnreal : ↑a ≠ ⊤ → ↑b ≠ ⊤ → ENNReal.toNNReal ↑a ≤ ENNReal.toNNReal ↑b
hlt : ↑b < ↑a
⊢ False

tactic: simpa using h_nnreal
state_before: case intro.intro
α : Type ?u.142320
β : Type ?u.142323
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
h : ↑a = ⊤ → ↑b = ⊤
h_nnreal : ↑a ≠ ⊤ → ↑b ≠ ⊤ → ENNReal.toNNReal ↑a ≤ ENNReal.toNNReal ↑b
hlt : ↑b < ↑a
⊢ ↑a ≤ ↑b
Theorem: IsUnit.div_div_cancel
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_div_eq_mul_div, h.mul_div_cancel_left]
state_before: F : Type ?u.66666
G : Type ?u.66669
α : Type u_1
M : Type ?u.66675
N : Type ?u.66678
inst✝ : DivisionCommMonoid α
a b c d : α
h : IsUnit a
⊢ a / (a / b) = b
Theorem: MeasureTheory.lintegral_fn_integral_sub
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: refine' lintegral_congr_ae _
state_before: α : Type u_1
α' : Type ?u.2423125
β : Type u_2
β' : Type ?u.2423131
γ : Type ?u.2423134
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type ?u.2423399
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → ℝ≥0∞
hf : Integrable f
hg : Integrable g
⊢ (∫⁻ (x : α), F (∫ (y : β), f (x, y) - g (x, y) ∂ν) ∂μ) =
    ∫⁻ (x : α), F ((∫ (y : β), f (x, y) ∂ν) - ∫ (y : β), g (x, y) ∂ν) ∂μ

tactic: filter_upwards [hf.prod_right_ae, hg.prod_right_ae] with _ h2f h2g
state_before: α : Type u_1
α' : Type ?u.2423125
β : Type u_2
β' : Type ?u.2423131
γ : Type ?u.2423134
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type ?u.2423399
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → ℝ≥0∞
hf : Integrable f
hg : Integrable g
⊢ (fun x => F (∫ (y : β), f (x, y) - g (x, y) ∂ν)) =ᶠ[ae μ] fun x =>
    F ((∫ (y : β), f (x, y) ∂ν) - ∫ (y : β), g (x, y) ∂ν)

tactic: simp [integral_sub h2f h2g]
state_before: case h
α : Type u_1
α' : Type ?u.2423125
β : Type u_2
β' : Type ?u.2423131
γ : Type ?u.2423134
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type ?u.2423399
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f g : α × β → E
F : E → ℝ≥0∞
hf : Integrable f
hg : Integrable g
a✝ : α
h2f : Integrable fun y => f (a✝, y)
h2g : Integrable fun y => g (a✝, y)
⊢ F (∫ (y : β), f (a✝, y) - g (a✝, y) ∂ν) = F ((∫ (y : β), f (a✝, y) ∂ν) - ∫ (y : β), g (a✝, y) ∂ν)
Theorem: Matrix.lieConj_symm_apply
File: Mathlib/Algebra/Lie/Matrix.lean

tactic: simp [LinearEquiv.symm_conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
  LinearMap.toMatrix'_toLin']
state_before: R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ ↑(LieEquiv.symm (lieConj P h)) A = P⁻¹ ⬝ A ⬝ P
Theorem: Int.div_sign
File: Std/Data/Int/DivMod.lean

tactic: simp [sign, Int.mul_one]
state_before: x✝ : Int
n✝ : Nat
⊢ div x✝ (sign ↑(succ n✝)) = x✝ * sign ↑(succ n✝)

tactic: simp [sign, Int.mul_zero]
state_before: x✝ : Int
⊢ div x✝ (sign 0) = x✝ * sign 0

tactic: simp [sign, Int.mul_neg, Int.mul_one]
state_before: x✝ : Int
a✝ : Nat
⊢ div x✝ (sign -[a✝+1]) = x✝ * sign -[a✝+1]
Theorem: MeasureTheory.AEEqFun.coeFn_abs
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp_rw [abs_eq_sup_neg]
state_before: α : Type u_2
β✝ : Type ?u.1579337
γ : Type ?u.1579340
δ : Type ?u.1579343
inst✝⁸ : MeasurableSpace α
μ ν : Measure α
inst✝⁷ : TopologicalSpace β✝
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : TopologicalSpace δ
β : Type u_1
inst✝⁴ : TopologicalSpace β
inst✝³ : Lattice β
inst✝² : TopologicalLattice β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
f : α →ₘ[μ] β
⊢ ↑(abs f) =ᵐ[μ] fun x => abs (↑f x)

tactic: filter_upwards [AEEqFun.coeFn_sup f (-f), AEEqFun.coeFn_neg f] with x hx_sup hx_neg
state_before: α : Type u_2
β✝ : Type ?u.1579337
γ : Type ?u.1579340
δ : Type ?u.1579343
inst✝⁸ : MeasurableSpace α
μ ν : Measure α
inst✝⁷ : TopologicalSpace β✝
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : TopologicalSpace δ
β : Type u_1
inst✝⁴ : TopologicalSpace β
inst✝³ : Lattice β
inst✝² : TopologicalLattice β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
f : α →ₘ[μ] β
⊢ ↑(f ⊔ -f) =ᵐ[μ] fun x => ↑f x ⊔ -↑f x

tactic: rw [hx_sup, hx_neg, Pi.neg_apply]
state_before: case h
α : Type u_2
β✝ : Type ?u.1579337
γ : Type ?u.1579340
δ : Type ?u.1579343
inst✝⁸ : MeasurableSpace α
μ ν : Measure α
inst✝⁷ : TopologicalSpace β✝
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : TopologicalSpace δ
β : Type u_1
inst✝⁴ : TopologicalSpace β
inst✝³ : Lattice β
inst✝² : TopologicalLattice β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
f : α →ₘ[μ] β
x : α
hx_sup : ↑(f ⊔ -f) x = ↑f x ⊔ ↑(-f) x
hx_neg : ↑(-f) x = (-↑f) x
⊢ ↑(f ⊔ -f) x = ↑f x ⊔ -↑f x
Theorem: MeasureTheory.HasFiniteIntegral.add_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [HasFiniteIntegral, lintegral_add_measure] at *
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.718349
δ : Type ?u.718352
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : HasFiniteIntegral f
hν : HasFiniteIntegral f
⊢ HasFiniteIntegral f

tactic: exact add_lt_top.2 ⟨hμ, hν⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.718349
δ : Type ?u.718352
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hμ : (∫⁻ (a : α), ↑‖f a‖₊ ∂μ) < ⊤
hν : (∫⁻ (a : α), ↑‖f a‖₊ ∂ν) < ⊤
⊢ ((∫⁻ (a : α), ↑‖f a‖₊ ∂μ) + ∫⁻ (a : α), ↑‖f a‖₊ ∂ν) < ⊤
Theorem: Decidable.not_iff_not
File: Std/Logic.lean

tactic: rw [@iff_def (¬a), @iff_def' a]
state_before: a b : Prop
inst✝¹ : Decidable a
inst✝ : Decidable b
⊢ (¬a ↔ ¬b) ↔ (a ↔ b)

tactic: exact and_congr not_imp_not not_imp_not
state_before: a b : Prop
inst✝¹ : Decidable a
inst✝ : Decidable b
⊢ (¬a → ¬b) ∧ (¬b → ¬a) ↔ (b → a) ∧ (a → b)
Theorem: Set.preimage_neg_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp only [← Icc_min_max, preimage_neg_Icc, min_neg_neg, max_neg_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ -[[a, b]] = [[-a, -b]]
Theorem: Finset.prod_update_of_not_mem
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: apply prod_congr rfl
state_before: ι : Type ?u.790472
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : ¬i ∈ s
f : α → β
b : β
⊢ ∏ x in s, Function.update f i b x = ∏ x in s, f x

tactic: intros j hj
state_before: ι : Type ?u.790472
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : ¬i ∈ s
f : α → β
b : β
⊢ ∀ (x : α), x ∈ s → Function.update f i b x = f x

tactic: have : j ≠ i := by
  rintro rfl
  exact h hj
state_before: ι : Type ?u.790472
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : ¬i ∈ s
f : α → β
b : β
j : α
hj : j ∈ s
⊢ Function.update f i b j = f j

tactic: simp [this]
state_before: ι : Type ?u.790472
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : ¬i ∈ s
f : α → β
b : β
j : α
hj : j ∈ s
this : j ≠ i
⊢ Function.update f i b j = f j

tactic: rintro rfl
state_before: ι : Type ?u.790472
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : ¬i ∈ s
f : α → β
b : β
j : α
hj : j ∈ s
⊢ j ≠ i

tactic: exact h hj
state_before: ι : Type ?u.790472
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
b : β
j : α
hj : j ∈ s
h : ¬j ∈ s
⊢ False
Theorem: Matrix.zpow_sub
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [sub_eq_add_neg, zpow_add ha, zpow_neg ha, div_eq_mul_inv]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
ha : IsUnit (det A)
z1 z2 : ℤ
⊢ A ^ (z1 - z2) = A ^ z1 / A ^ z2
Theorem: GaloisInsertion.l_sSup_u_image
File: Mathlib/Order/GaloisConnection.lean

tactic: rw [sSup_image, gi.l_biSup_u, sSup_eq_iSup]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.39544
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
s : Set β
⊢ l (sSup (u '' s)) = sSup s
Theorem: Ideal.isIdempotentElem_iff_eq_bot_or_top
File: Mathlib/RingTheory/Ideal/IdempotentFG.lean

tactic: constructor
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
I : Ideal R
h : FG I
⊢ IsIdempotentElem I ↔ I = ⊥ ∨ I = ⊤

tactic: intro H
state_before: case mp
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
I : Ideal R
h : FG I
⊢ IsIdempotentElem I → I = ⊥ ∨ I = ⊤

tactic: obtain ⟨e, he, rfl⟩ := (I.isIdempotentElem_iff_of_fg h).mp H
state_before: case mp
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
I : Ideal R
h : FG I
H : IsIdempotentElem I
⊢ I = ⊥ ∨ I = ⊤

tactic: simp only [Ideal.submodule_span_eq, Ideal.span_singleton_eq_bot]
state_before: case mp.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
e : R
he : IsIdempotentElem e
h : FG (Submodule.span R {e})
H : IsIdempotentElem (Submodule.span R {e})
⊢ Submodule.span R {e} = ⊥ ∨ Submodule.span R {e} = ⊤

tactic: apply Or.imp id _ (IsIdempotentElem.iff_eq_zero_or_one.mp he)
state_before: case mp.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
e : R
he : IsIdempotentElem e
h : FG (Submodule.span R {e})
H : IsIdempotentElem (Submodule.span R {e})
⊢ e = 0 ∨ span {e} = ⊤

tactic: rintro rfl
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
e : R
he : IsIdempotentElem e
h : FG (Submodule.span R {e})
H : IsIdempotentElem (Submodule.span R {e})
⊢ e = 1 → span {e} = ⊤

tactic: simp
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
he : IsIdempotentElem 1
h : FG (Submodule.span R {1})
H : IsIdempotentElem (Submodule.span R {1})
⊢ span {1} = ⊤

tactic: rintro (rfl | rfl) <;> simp [IsIdempotentElem]
state_before: case mpr
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
I : Ideal R
h : FG I
⊢ I = ⊥ ∨ I = ⊤ → IsIdempotentElem I
Theorem: VectorBundleCore.localTriv_coordChange_eq
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [Trivialization.coordChangeL_apply', localTriv_symm_fst, localTriv_apply, coordChange_comp]
state_before: R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.414625
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i ∩ baseSet Z j
v : F
⊢ ↑(Trivialization.coordChangeL R (localTriv Z i) (localTriv Z j) b) v = ↑(coordChange Z i j b) v

tactic: exacts [⟨⟨hb.1, Z.mem_baseSet_at b⟩, hb.2⟩, hb]
state_before: case a
R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.414625
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i ∩ baseSet Z j
v : F
⊢ { fst := (b, v).fst, snd := ↑(coordChange Z i (indexAt Z (b, v).fst) (b, v).fst) (b, v).snd }.fst ∈
    baseSet Z i ∩
        baseSet Z
          (indexAt Z
            { fst := (b, v).fst, snd := ↑(coordChange Z i (indexAt Z (b, v).fst) (b, v).fst) (b, v).snd }.fst) ∩
      baseSet Z j

case hb
R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.414625
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i ∩ baseSet Z j
v : F
⊢ b ∈ (localTriv Z i).baseSet ∩ (localTriv Z j).baseSet
Theorem: IsCompact.isClosed
File: Mathlib/Topology/Separation.lean

tactic: simpa using xv
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.129636
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
s : Set α
hs : IsCompact s
x : α
hx : x ∈ sᶜ
u v : Set α
left✝ : IsOpen u
vo : IsOpen v
su : s ⊆ u
xv : {x} ⊆ v
uv : Disjoint u v
⊢ x ∈ v