tasksource/leandojo huggingface dataset:
Theorem: Std.RBNode.Balanced.balLeft
File: Std/Data/RBMap/WF.lean

tactic: unfold balLeft
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : Balanced r cr (n + 1)
⊢ RedRed (cr = red) (balLeft l v r) (n + 1)

tactic: split
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : Balanced r cr (n + 1)
⊢ RedRed (cr = red)
    (match l with
    | node red a x b => node red (node black a x b) v r
    | l =>
      match r with
      | node black a y b => balance2 l v (node red a y b)
      | node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c))
      | r => node red l v r)
    (n + 1)

tactic: next a x b => exact
let ⟨ca, cb, ha, hb⟩ := hl.of_red
match cr with
| red => .redred rfl (.black ha hb) hr
| black => .balanced (.red (.black ha hb) hr)
state_before: case h_1
α✝ : Type u_1
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hr : Balanced r cr (n + 1)
l✝ a✝ : RBNode α✝
x✝ : α✝
b✝ : RBNode α✝
hl : RedRed True (node red a✝ x✝ b✝) n
⊢ RedRed (cr = red) (node red (node black a✝ x✝ b✝) v r) (n + 1)

tactic: exact
let ⟨ca, cb, ha, hb⟩ := hl.of_red
match cr with
| red => .redred rfl (.black ha hb) hr
| black => .balanced (.red (.black ha hb) hr)
state_before: α✝ : Type u_1
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hr : Balanced r cr (n + 1)
l✝ a : RBNode α✝
x : α✝
b : RBNode α✝
hl : RedRed True (node red a x b) n
⊢ RedRed (cr = red) (node red (node black a x b) v r) (n + 1)

tactic: next H => exact match hl with
| .redred .. => nomatch H _ _ _ rfl
| .balanced hl => match hr with
  | .black ha hb =>
    let ⟨c, h⟩ := RedRed.balance2 hl (.redred trivial ha hb); .balanced h
  | .red (.black ha hb) (.black hc hd) =>
    let ⟨c, h⟩ := RedRed.balance2 hb (.redred trivial hc hd); .redred rfl (.black hl ha) h
state_before: case h_2
α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : Balanced r cr (n + 1)
l✝ : RBNode α✝
x✝ : ∀ (a : RBNode α✝) (x : α✝) (b : RBNode α✝), l = node red a x b → False
⊢ RedRed (cr = red)
    (match r with
    | node black a y b => balance2 l v (node red a y b)
    | node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c))
    | r => node red l v r)
    (n + 1)

tactic: exact match hl with
| .redred .. => nomatch H _ _ _ rfl
| .balanced hl => match hr with
| .black ha hb =>
let ⟨c, h⟩ := RedRed.balance2 hl (.redred trivial ha hb); .balanced h
| .red (.black ha hb) (.black hc hd) =>
let ⟨c, h⟩ := RedRed.balance2 hb (.redred trivial hc hd); .redred rfl (.black hl ha) h
state_before: α✝ : Type u_1
l : RBNode α✝
v : α✝
r : RBNode α✝
cr : RBColor
n : Nat
hl : RedRed True l n
hr : Balanced r cr (n + 1)
l✝ : RBNode α✝
H : ∀ (a : RBNode α✝) (x : α✝) (b : RBNode α✝), l = node red a x b → False
⊢ RedRed (cr = red)
    (match r with
    | node black a y b => balance2 l v (node red a y b)
    | node red (node black a y b) z c => node red (node black l v a) y (balance2 b z (setRed c))
    | r => node red l v r)
    (n + 1)
Theorem: LucasLehmer.X.ωb_mul_ω
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [mul_comm, ω_mul_ωb]
state_before: q✝ q : ℕ+
⊢ ωb * ω = 1
Theorem: Nat.multiplicity_eq_factorization
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization, pp, padicValNat_def' pp.ne_one hn.bot_lt]
state_before: n p : ℕ
pp : Prime p
hn : n ≠ 0
⊢ multiplicity p n = ↑(↑(factorization n) p)
Theorem: Polynomial.degree_eq_iff_natDegree_eq
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [degree_eq_natDegree hp]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hp : p ≠ 0
⊢ degree p = ↑n ↔ natDegree p = n

tactic: exact WithBot.coe_eq_coe
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hp : p ≠ 0
⊢ ↑(natDegree p) = ↑n ↔ natDegree p = n
Theorem: PiLp.norm_sq_eq_of_L2
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: suffices ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2 by
  simpa only [NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) this
state_before: p : ℝ≥0∞
𝕜 : Type ?u.285404
𝕜' : Type ?u.285407
ι : Type u_2
α : ι → Type ?u.285415
β✝ : ι → Type ?u.285420
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2

tactic: rw [nnnorm_eq_of_L2, NNReal.sq_sqrt]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.285404
𝕜' : Type ?u.285407
ι : Type u_2
α : ι → Type ?u.285415
β✝ : ι → Type ?u.285420
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2

tactic: simpa only [NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) this
state_before: p : ℝ≥0∞
𝕜 : Type ?u.285404
𝕜' : Type ?u.285407
ι : Type u_2
α : ι → Type ?u.285415
β✝ : ι → Type ?u.285420
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
this : ‖x‖₊ ^ 2 = ∑ i : ι, ‖x i‖₊ ^ 2
⊢ ‖x‖ ^ 2 = ∑ i : ι, ‖x i‖ ^ 2
Theorem: dist_vsub_vsub_le
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

tactic: rw [dist_eq_norm, vsub_sub_vsub_comm, dist_eq_norm_vsub V, dist_eq_norm_vsub V]
state_before: α : Type ?u.24677
V : Type u_1
P : Type u_2
W : Type ?u.24686
Q : Type ?u.24689
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ dist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ dist p₁ p₃ + dist p₂ p₄

tactic: exact norm_sub_le _ _
state_before: α : Type ?u.24677
V : Type u_1
P : Type u_2
W : Type ?u.24686
Q : Type ?u.24689
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ ‖p₁ -ᵥ p₃ - (p₂ -ᵥ p₄)‖ ≤ ‖p₁ -ᵥ p₃‖ + ‖p₂ -ᵥ p₄‖
Theorem: FirstOrder.Language.Substructure.skolem₁_reduct_isElementary
File: Mathlib/ModelTheory/Skolem.lean

tactic: apply (LHom.sumInl.substructureReduct S).isElementary_of_exists
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
S : Substructure (Language.sum L (skolem₁ L)) M
⊢ IsElementary (↑(LHom.substructureReduct LHom.sumInl) S)

tactic: intro n φ x a h
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
S : Substructure (Language.sum L (skolem₁ L)) M
⊢ ∀ (n : ℕ) (φ : BoundedFormula L Empty (n + 1)) (x : Fin n → { x // x ∈ ↑(LHom.substructureReduct LHom.sumInl) S })
    (a : M),
    BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) a) →
      ∃ b, BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) ↑b)

tactic: let φ' : (L.sum L.skolem₁).Functions n := LHom.sumInr.onFunction φ
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
S : Substructure (Language.sum L (skolem₁ L)) M
n : ℕ
φ : BoundedFormula L Empty (n + 1)
x : Fin n → { x // x ∈ ↑(LHom.substructureReduct LHom.sumInl) S }
a : M
h : BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) a)
⊢ ∃ b, BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) ↑b)

tactic: exact
  ⟨⟨funMap φ' ((↑) ∘ x), S.fun_mem (LHom.sumInr.onFunction φ) ((↑) ∘ x) (by
    exact fun i => (x i).2)⟩,
    by exact Classical.epsilon_spec (p := fun a => BoundedFormula.Realize φ default
        (Fin.snoc (Subtype.val ∘ x) a)) ⟨a, h⟩⟩
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
S : Substructure (Language.sum L (skolem₁ L)) M
n : ℕ
φ : BoundedFormula L Empty (n + 1)
x : Fin n → { x // x ∈ ↑(LHom.substructureReduct LHom.sumInl) S }
a : M
h : BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) a)
φ' : Functions (Language.sum L (skolem₁ L)) n := LHom.onFunction LHom.sumInr φ
⊢ ∃ b, BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) ↑b)

tactic: exact fun i => (x i).2
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
S : Substructure (Language.sum L (skolem₁ L)) M
n : ℕ
φ : BoundedFormula L Empty (n + 1)
x : Fin n → { x // x ∈ ↑(LHom.substructureReduct LHom.sumInl) S }
a : M
h : BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) a)
φ' : Functions (Language.sum L (skolem₁ L)) n := LHom.onFunction LHom.sumInr φ
⊢ ∀ (i : Fin n), (Subtype.val ∘ x) i ∈ ↑S

tactic: exact Classical.epsilon_spec (p := fun a => BoundedFormula.Realize φ default
 (Fin.snoc (Subtype.val ∘ x) a)) ⟨a, h⟩
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
S : Substructure (Language.sum L (skolem₁ L)) M
n : ℕ
φ : BoundedFormula L Empty (n + 1)
x : Fin n → { x // x ∈ ↑(LHom.substructureReduct LHom.sumInl) S }
a : M
h : BoundedFormula.Realize φ default (Fin.snoc (Subtype.val ∘ x) a)
φ' : Functions (Language.sum L (skolem₁ L)) n := LHom.onFunction LHom.sumInr φ
⊢ BoundedFormula.Realize φ default
    (Fin.snoc (Subtype.val ∘ x)
      ↑{ val := funMap φ' (Subtype.val ∘ x),
          property := (_ : funMap (LHom.onFunction LHom.sumInr φ) (Subtype.val ∘ x) ∈ ↑S) })
Theorem: Metric.ne_of_mem_sphere
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simpa using hε.symm
state_before: α : Type u
β : Type v
X : Type ?u.32596
ι : Type ?u.32599
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : y ∈ sphere x ε
hε : ε ≠ 0
⊢ ¬x ∈ sphere x ε
Theorem: MulChar.IsNontrivial.sum_eq_zero
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: rcases hχ with ⟨b, hb⟩
state_before: R : Type u
inst✝⁴ : CommRing R
R' : Type v
inst✝³ : CommRing R'
R'' : Type w
inst✝² : CommRing R''
inst✝¹ : Fintype R
inst✝ : IsDomain R'
χ : MulChar R R'
hχ : IsNontrivial χ
⊢ ∑ a : R, ↑χ a = 0

tactic: refine' eq_zero_of_mul_eq_self_left hb _
state_before: case intro
R : Type u
inst✝⁴ : CommRing R
R' : Type v
inst✝³ : CommRing R'
R'' : Type w
inst✝² : CommRing R''
inst✝¹ : Fintype R
inst✝ : IsDomain R'
χ : MulChar R R'
b : Rˣ
hb : ↑χ ↑b ≠ 1
⊢ ∑ a : R, ↑χ a = 0

tactic: simp only [Finset.mul_sum, ← map_mul]
state_before: case intro
R : Type u
inst✝⁴ : CommRing R
R' : Type v
inst✝³ : CommRing R'
R'' : Type w
inst✝² : CommRing R''
inst✝¹ : Fintype R
inst✝ : IsDomain R'
χ : MulChar R R'
b : Rˣ
hb : ↑χ ↑b ≠ 1
⊢ ↑χ ↑b * ∑ a : R, ↑χ a = ∑ a : R, ↑χ a

tactic: refine Fintype.sum_bijective _ (Units.mulLeft_bijective b) _ _ fun x => ?_
state_before: case intro
R : Type u
inst✝⁴ : CommRing R
R' : Type v
inst✝³ : CommRing R'
R'' : Type w
inst✝² : CommRing R''
inst✝¹ : Fintype R
inst✝ : IsDomain R'
χ : MulChar R R'
b : Rˣ
hb : ↑χ ↑b ≠ 1
⊢ ∑ x : R, ↑χ ↑b * ↑χ x = ∑ a : R, ↑χ a

tactic: exact (map_mul χ (b : R) x).symm
state_before: case intro
R : Type u
inst✝⁴ : CommRing R
R' : Type v
inst✝³ : CommRing R'
R'' : Type w
inst✝² : CommRing R''
inst✝¹ : Fintype R
inst✝ : IsDomain R'
χ : MulChar R R'
b : Rˣ
hb : ↑χ ↑b ≠ 1
x : R
⊢ ↑χ ↑b * ↑χ x = ↑χ (↑b * x)
Theorem: isSquare_op_iff
File: Mathlib/Algebra/Parity.lean

tactic: rw [← unop_mul, ← hc, unop_op]
state_before: F : Type ?u.311
α : Type u_1
β : Type ?u.317
R : Type ?u.320
inst✝ : Mul α
a : α
x✝ : IsSquare (op a)
c : αᵐᵒᵖ
hc : op a = c * c
⊢ a = unop c * unop c

tactic: simp [hc]
state_before: F : Type ?u.311
α : Type u_1
β : Type ?u.317
R : Type ?u.320
inst✝ : Mul α
a : α
x✝ : IsSquare a
c : α
hc : a = c * c
⊢ IsSquare (op a)
Theorem: Subgroup.zpowers_eq_bot
File: Mathlib/GroupTheory/Subgroup/ZPowers.lean

tactic: rw [eq_bot_iff, zpowers_le, mem_bot]
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.38880
inst✝¹ : AddGroup A
N : Type ?u.38886
inst✝ : Group N
s : Set G
g✝ g : G
⊢ zpowers g = ⊥ ↔ g = 1
Theorem: DiscreteQuotient.ofLE_map
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: rcases a with ⟨⟩
state_before: α : Type ?u.32610
X : Type u_1
Y : Type u_2
Z : Type ?u.32619
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
cond : LEComap f A B
h : B ≤ B'
a : Quotient A.toSetoid
⊢ ofLE h (map f cond a) = map f (_ : LEComap f A B') a

tactic: rfl
state_before: case mk
α : Type ?u.32610
X : Type u_1
Y : Type u_2
Z : Type ?u.32619
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
cond : LEComap f A B
h : B ≤ B'
a : Quotient A.toSetoid
a✝ : X
⊢ ofLE h (map f cond (Quot.mk Setoid.r a✝)) = map f (_ : LEComap f A B') (Quot.mk Setoid.r a✝)
Theorem: ProbabilityTheory.kernel.ext_fun_iff
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [h]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.364824
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : { x // x ∈ kernel α β }
h : κ = η
a : α
f : β → ℝ≥0∞
x✝ : Measurable f
⊢ (∫⁻ (b : β), f b ∂↑κ a) = ∫⁻ (b : β), f b ∂↑η a
Theorem: List.formPerm_eq_head_iff_eq_getLast
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rw [formPerm_apply_getLast]
state_before: α : Type u_1
β : Type ?u.671041
inst✝ : DecidableEq α
l : List α
x✝ x y : α
⊢ ↑(formPerm (y :: l)) x = y ↔ ↑(formPerm (y :: l)) x = ↑(formPerm (y :: l)) (getLast (y :: l) (_ : y :: l ≠ []))
Theorem: LieSubmodule.lie_coe_mem_lie
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [lieIdeal_oper_eq_span]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : { x // x ∈ I }
m : { x // x ∈ N }
⊢ ⁅↑x, ↑m⁆ ∈ ⁅I, N⁆

tactic: apply subset_lieSpan
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : { x // x ∈ I }
m : { x // x ∈ N }
⊢ ⁅↑x, ↑m⁆ ∈ lieSpan R L {m | ∃ x n, ⁅↑x, ↑n⁆ = m}

tactic: use x, m
state_before: case a
R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
x : { x // x ∈ I }
m : { x // x ∈ N }
⊢ ⁅↑x, ↑m⁆ ∈ {m | ∃ x n, ⁅↑x, ↑n⁆ = m}
Theorem: IsROrC.sqrt_normSq_eq_norm
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [normSq_eq_def', Real.sqrt_sq (norm_nonneg _)]
state_before: K : Type u_1
E : Type ?u.5321595
inst✝ : IsROrC K
z : K
⊢ Real.sqrt (↑normSq z) = ‖z‖
Theorem: Polynomial.Monic.normalize_eq_self
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp only [Polynomial.coe_normUnit, normalize_apply, hp.leadingCoeff, normUnit_one,
  Units.val_one, Polynomial.C.map_one, mul_one]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizationMonoid R
p : R[X]
hp : Monic p
⊢ ↑normalize p = p
Theorem: Real.ofCauchy_inv
File: Mathlib/Data/Real/Basic.lean

tactic: rw [inv']
state_before: x y : ℝ
f : Cauchy abs
⊢ { cauchy := f⁻¹ } = Real.inv' { cauchy := f }
Theorem: Filter.tendsto_iff_rtendsto'
File: Mathlib/Order/Filter/Partial.lean

tactic: simp [tendsto_def, Function.graph, rtendsto'_def, Rel.preimage_def, Set.preimage]
state_before: α : Type u
β : Type v
γ : Type w
l₁ : Filter α
l₂ : Filter β
f : α → β
⊢ Tendsto f l₁ l₂ ↔ RTendsto' (Function.graph f) l₁ l₂
Theorem: StieltjesFunction.measurableSet_Ioi
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine OuterMeasure.ofFunction_caratheodory fun t => ?_
state_before: f : StieltjesFunction
c : ℝ
⊢ MeasurableSet (Ioi c)

tactic: refine' le_iInf fun a => le_iInf fun b => le_iInf fun h => _
state_before: f : StieltjesFunction
c : ℝ
t : Set ℝ
⊢ length f (t ∩ Ioi c) + length f (t \ Ioi c) ≤ length f t

tactic: refine'
  le_trans
    (add_le_add (f.length_mono <| inter_subset_inter_left _ h)
      (f.length_mono <| diff_subset_diff_left h)) _
state_before: f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
⊢ length f (t ∩ Ioi c) + length f (t \ Ioi c) ≤ ofReal (↑f b - ↑f a)

tactic: cases' le_total a c with hac hac <;> cases' le_total b c with hbc hbc
state_before: f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
⊢ length f (Ioc a b ∩ Ioi c) + length f (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

tactic: simp only [Ioc_inter_Ioi, f.length_Ioc, hac, _root_.sup_eq_max, hbc, le_refl, Ioc_eq_empty,
  max_eq_right, min_eq_left, Ioc_diff_Ioi, f.length_empty, zero_add, not_lt]
state_before: case inl.inl
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : a ≤ c
hbc : b ≤ c
⊢ length f (Ioc a b ∩ Ioi c) + length f (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

tactic: simp only [hac, hbc, Ioc_inter_Ioi, Ioc_diff_Ioi, f.length_Ioc, min_eq_right,
  _root_.sup_eq_max, ← ENNReal.ofReal_add, f.mono hac, f.mono hbc, sub_nonneg,
  sub_add_sub_cancel, le_refl,
  max_eq_right]
state_before: case inl.inr
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : a ≤ c
hbc : c ≤ b
⊢ length f (Ioc a b ∩ Ioi c) + length f (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

tactic: simp only [hbc, le_refl, Ioc_eq_empty, Ioc_inter_Ioi, min_eq_left, Ioc_diff_Ioi, f.length_empty,
  zero_add, or_true_iff, le_sup_iff, f.length_Ioc, not_lt]
state_before: case inr.inl
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : c ≤ a
hbc : b ≤ c
⊢ length f (Ioc a b ∩ Ioi c) + length f (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)

tactic: simp only [hac, hbc, Ioc_inter_Ioi, Ioc_diff_Ioi, f.length_Ioc, min_eq_right, _root_.sup_eq_max,
  le_refl, Ioc_eq_empty, add_zero, max_eq_left, f.length_empty, not_lt]
state_before: case inr.inr
f : StieltjesFunction
c : ℝ
t : Set ℝ
a b : ℝ
h : t ⊆ Ioc a b
hac : c ≤ a
hbc : c ≤ b
⊢ length f (Ioc a b ∩ Ioi c) + length f (Ioc a b \ Ioi c) ≤ ofReal (↑f b - ↑f a)
Theorem: MeasureTheory.integral_Icc_eq_integral_Ioo
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [integral_Icc_eq_integral_Ico, integral_Ico_eq_integral_Ioo]
state_before: α : Type u_2
β : Type ?u.279314
E : Type u_1
F : Type ?u.279320
inst✝⁵ : MeasurableSpace α
inst✝⁴ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
inst✝¹ : PartialOrder α
a b : α
inst✝ : NoAtoms μ
⊢ (∫ (t : α) in Icc a b, f t ∂μ) = ∫ (t : α) in Ico a b, f t ∂μ
Theorem: Real.hasStrictDerivAt_const_rpow_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simpa using (hasStrictFDerivAt_rpow_of_neg (a, x) ha).comp_hasStrictDerivAt x
  ((hasStrictDerivAt_const _ _).prod (hasStrictDerivAt_id _))
state_before: x✝ y z a x : ℝ
ha : a < 0
⊢ HasStrictDerivAt (fun x => a ^ x) (a ^ x * log a - exp (log a * x) * sin (x * π) * π) x
Theorem: closure_compl
File: Mathlib/Topology/Basic.lean

tactic: simp [closure_eq_compl_interior_compl]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ closure (sᶜ) = interior sᶜ
Theorem: Nat.lxor_cancel_right
File: Mathlib/Data/Nat/Bitwise.lean

tactic: rw [lxor'_assoc, lxor'_self, lxor'_zero]
state_before: n m : ℕ
⊢ lxor' (lxor' m n) n = m
Theorem: Int.add_mul
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.mul_comm, Int.mul_add]
state_before: a b c : Int
⊢ (a + b) * c = a * c + b * c
Theorem: IsROrC.natCast_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_natCast, ofReal_re]
state_before: K : Type u_1
E : Type ?u.6224464
inst✝ : IsROrC K
n : ℕ
⊢ ↑re ↑n = ↑n
Theorem: CategoryTheory.Limits.map_π_preserves_coequalizer_inv_colimMap
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean

tactic: rw [← Category.assoc, map_π_preserves_coequalizer_inv, ι_colimMap, parallelPairHom_app_one]
state_before: C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = g ≫ h
inst✝³ : HasCoequalizer f g
inst✝² : HasCoequalizer (G.map f) (G.map g)
inst✝¹ : PreservesColimit (parallelPair f g) G
X' Y' : D
f' g' : X' ⟶ Y'
inst✝ : HasCoequalizer f' g'
p : G.obj X ⟶ X'
q : G.obj Y ⟶ Y'
wf : G.map f ≫ q = p ≫ f'
wg : G.map g ≫ q = p ≫ g'
⊢ G.map (coequalizer.π f g) ≫
      (PreservesCoequalizer.iso G f g).inv ≫ colimMap (parallelPairHom (G.map f) (G.map g) f' g' p q wf wg) =
    q ≫ coequalizer.π f' g'
Theorem: ContinuousMap.sup_mem_closed_subalgebra
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

tactic: convert sup_mem_subalgebra_closure A f g
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : { x // x ∈ A }
⊢ ↑f ⊔ ↑g ∈ A

tactic: apply SetLike.ext'
state_before: case h.e'_5
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : { x // x ∈ A }
⊢ A = Subalgebra.topologicalClosure A

tactic: symm
state_before: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : { x // x ∈ A }
⊢ ↑A = ↑(Subalgebra.topologicalClosure A)

tactic: erw [closure_eq_iff_isClosed]
state_before: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : { x // x ∈ A }
⊢ ↑(Subalgebra.topologicalClosure A) = ↑A

tactic: exact h
state_before: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : { x // x ∈ A }
⊢ IsClosed ↑A
Theorem: one_div_neg_eq_neg_one_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [neg_eq_neg_one_mul]
state_before: α : Type ?u.23152
β : Type ?u.23155
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b a : K
⊢ 1 / -a = 1 / (-1 * a)

tactic: rw [one_div_mul_one_div_rev]
state_before: α : Type ?u.23152
β : Type ?u.23155
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b a : K
⊢ 1 / (-1 * a) = 1 / a * (1 / -1)

tactic: rw [one_div_neg_one_eq_neg_one]
state_before: α : Type ?u.23152
β : Type ?u.23155
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b a : K
⊢ 1 / a * (1 / -1) = 1 / a * -1

tactic: rw [mul_neg, mul_one]
state_before: α : Type ?u.23152
β : Type ?u.23155
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b a : K
⊢ 1 / a * -1 = -(1 / a)
Theorem: Real.arctan_eq_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [arctan_eq_arcsin, arccos_eq_arcsin]
state_before: x : ℝ
h : 0 ≤ x
⊢ arctan x = arccos (sqrt (↑1 + x ^ 2))⁻¹

tactic: swap
state_before: x : ℝ
h : 0 ≤ x
⊢ arcsin (x / sqrt (↑1 + x ^ 2)) = arcsin (sqrt (1 - (sqrt (↑1 + x ^ 2))⁻¹ ^ 2))

x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (sqrt (↑1 + x ^ 2))⁻¹

tactic: congr 1
state_before: x : ℝ
h : 0 ≤ x
⊢ arcsin (x / sqrt (↑1 + x ^ 2)) = arcsin (sqrt (1 - (sqrt (↑1 + x ^ 2))⁻¹ ^ 2))

tactic: rw_mod_cast [← sqrt_inv, sq_sqrt, ← one_div, one_sub_div, add_sub_cancel', sqrt_div, sqrt_sq h]
state_before: case e_a
x : ℝ
h : 0 ≤ x
⊢ x / sqrt (↑1 + x ^ 2) = sqrt (1 - (sqrt (↑1 + x ^ 2))⁻¹ ^ 2)

tactic: all_goals positivity
state_before: case e_a.hx
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ x ^ 2

case e_a
x : ℝ
h : 0 ≤ x
⊢ 1 + x ^ 2 ≠ 0

case e_a
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (1 + x ^ 2)⁻¹

tactic: exact inv_nonneg.2 (sqrt_nonneg _)
state_before: x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (sqrt (↑1 + x ^ 2))⁻¹

tactic: positivity
state_before: case e_a
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (1 + x ^ 2)⁻¹