tasksource/leandojo huggingface dataset:
Theorem: Real.Angle.two_nsmul_neg_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_nsmul_coe_div_two, coe_neg, neg_coe_pi]
state_before: ⊢ 2 • ↑(-π / 2) = ↑π
Theorem: disjoint_compl_compl_left_iff
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [← le_compl_iff_disjoint_left, compl_compl_compl]
state_before: ι : Type ?u.163358
α : Type u_1
β : Type ?u.163364
inst✝ : HeytingAlgebra α
a b c : α
⊢ Disjoint (aᶜᶜ) b ↔ Disjoint a b
Theorem: Ordinal.mod_opow_log_lt_self
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rcases eq_or_ne b 0 with (rfl | hb)
state_before: b o : Ordinal
ho : o ≠ 0
⊢ o % b ^ log b o < o

tactic: simpa using Ordinal.pos_iff_ne_zero.2 ho
state_before: case inl
o : Ordinal
ho : o ≠ 0
⊢ o % 0 ^ log 0 o < o

tactic: exact (mod_lt _ <| opow_ne_zero _ hb).trans_le (opow_log_le_self _ ho)
state_before: case inr
b o : Ordinal
ho : o ≠ 0
hb : b ≠ 0
⊢ o % b ^ log b o < o
Theorem: Polynomial.divByMonic_eq_zero_iff
File: Mathlib/Data/Polynomial/Div.lean

tactic: have := modByMonic_add_div p hq
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : Nontrivial R
hq : Monic q
h : p /ₘ q = 0
⊢ degree p < degree q

tactic: rwa [h, MulZeroClass.mul_zero, add_zero, modByMonic_eq_self_iff hq] at this
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : Nontrivial R
hq : Monic q
h : p /ₘ q = 0
this : p %ₘ q + q * (p /ₘ q) = p
⊢ degree p < degree q

tactic: have : ¬degree q ≤ degree p := not_le_of_gt h
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : Nontrivial R
hq : Monic q
h : degree p < degree q
⊢ p /ₘ q = 0

tactic: unfold divByMonic divModByMonicAux
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : Nontrivial R
hq : Monic q
h : degree p < degree q
this : ¬degree q ≤ degree p
⊢ p /ₘ q = 0

tactic: dsimp
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : Nontrivial R
hq : Monic q
h : degree p < degree q
this : ¬degree q ≤ degree p
⊢ (if h : Monic q then
      (if h_1 : degree q ≤ degree p ∧ p ≠ 0 then
          let z := ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q);
          let_fun _wf := (_ : degree (p - ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) * q) < degree p);
          let dm := divModByMonicAux (p - z * q) (_ : Monic q);
          (z + dm.fst, dm.snd)
        else (0, p)).fst
    else 0) =
    0

tactic: rw [dif_pos hq, if_neg (mt And.left this)]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : Nontrivial R
hq : Monic q
h : degree p < degree q
this : ¬degree q ≤ degree p
⊢ (if h : Monic q then
      (if degree q ≤ degree p ∧ ¬p = 0 then
          (↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) +
              (divModByMonicAux (p - ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) * q) (_ : Monic q)).fst,
            (divModByMonicAux (p - ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree q) * q) (_ : Monic q)).snd)
        else (0, p)).fst
    else 0) =
    0
Theorem: Turing.ToPartrec.Code.case_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: f g : Code
⊢ eval (case f g) = fun v => Nat.rec (eval f (List.tail v)) (fun y x => eval g (y :: List.tail v)) (List.headI v)
Theorem: SymAlg.mul_def
File: Mathlib/Algebra/Symmetrized.lean

tactic: rfl
state_before: α : Type u_1
inst✝⁴ : Add α
inst✝³ : Mul α
inst✝² : One α
inst✝¹ : OfNat α 2
inst✝ : Invertible 2
a b : αˢʸᵐ
⊢ a * b = ↑sym (⅟2 * (↑unsym a * ↑unsym b + ↑unsym b * ↑unsym a))
Theorem: Finset.Ico_diff_Ico_left
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: cases le_total a c with
| inl h =>
  ext x
  rw [mem_sdiff, mem_Ico, mem_Ico, mem_Ico, max_eq_right h, and_right_comm, not_and, not_lt]
  exact and_congr_left' ⟨fun hx => hx.2 hx.1, fun hx => ⟨h.trans hx, fun _ => hx⟩⟩
| inr h => rw [Ico_eq_empty_of_le h, sdiff_empty, max_eq_left h]
state_before: ι : Type ?u.155748
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ Ico a b \ Ico a c = Ico (max a c) b

tactic: ext x
state_before: case inl
ι : Type ?u.155748
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : a ≤ c
⊢ Ico a b \ Ico a c = Ico (max a c) b

tactic: rw [mem_sdiff, mem_Ico, mem_Ico, mem_Ico, max_eq_right h, and_right_comm, not_and, not_lt]
state_before: case inl.a
ι : Type ?u.155748
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : a ≤ c
x : α
⊢ x ∈ Ico a b \ Ico a c ↔ x ∈ Ico (max a c) b

tactic: exact and_congr_left' ⟨fun hx => hx.2 hx.1, fun hx => ⟨h.trans hx, fun _ => hx⟩⟩
state_before: case inl.a
ι : Type ?u.155748
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : a ≤ c
x : α
⊢ (a ≤ x ∧ (a ≤ x → c ≤ x)) ∧ x < b ↔ c ≤ x ∧ x < b

tactic: rw [Ico_eq_empty_of_le h, sdiff_empty, max_eq_left h]
state_before: case inr
ι : Type ?u.155748
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : c ≤ a
⊢ Ico a b \ Ico a c = Ico (max a c) b
Theorem: Finset.prod_subtype_eq_prod_filter
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: conv_lhs => erw [← prod_map (s.subtype p) (Function.Embedding.subtype _) f]
state_before: ι : Type ?u.379810
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
f : α → β
p : α → Prop
inst✝ : DecidablePred p
⊢ ∏ x in Finset.subtype p s, f ↑x = ∏ x in filter p s, f x

tactic: exact prod_congr (subtype_map _) fun x _hx => rfl
state_before: ι : Type ?u.379810
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
f : α → β
p : α → Prop
inst✝ : DecidablePred p
⊢ ∏ x in map (Function.Embedding.subtype p) (Finset.subtype p s), f x = ∏ x in filter p s, f x
Theorem: Polynomial.monomial_mul_C
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp only [← monomial_zero_left, monomial_mul_monomial, add_zero]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ↑(monomial n) a * ↑C b = ↑(monomial n) (a * b)
Theorem: Nat.Partrec.Code.curry_inj
File: Mathlib/Computability/PartrecCode.lean

tactic: injection h
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h : curry c₁ n₁ = curry c₂ n₂
⊢ c₁ = c₂

tactic: injection h with h₁ h₂
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h : curry c₁ n₁ = curry c₂ n₂
⊢ n₁ = n₂

tactic: injection h₂ with h₃ h₄
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₂ : pair (Code.const n₁) Code.id = pair (Code.const n₂) Code.id
⊢ n₁ = n₂

tactic: exact const_inj h₃
state_before: c₁ c₂ : Code
n₁ n₂ : ℕ
h₁ : c₁ = c₂
h₃ : Code.const n₁ = Code.const n₂
h₄ : Code.id = Code.id
⊢ n₁ = n₂
Theorem: Matrix.dotProduct_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: simp [dotProduct, Fin.sum_univ_succ, vecHead, vecTail]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
v : Fin (Nat.succ n) → α
x : α
w : Fin n → α
⊢ v ⬝ᵥ vecCons x w = vecHead v * x + vecTail v ⬝ᵥ w
Theorem: Cardinal.extend_function_finite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply extend_function.{v, u} f
state_before: α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
⊢ ∃ g, ∀ (x : ↑s), ↑g ↑x = ↑f x

tactic: cases' id h with g
state_before: α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
⊢ Nonempty (↑(sᶜ) ≃ ↑(range ↑fᶜ))

tactic: rw [← lift_mk_eq.{u, v, max u v}] at h
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
g : α ≃ β
⊢ Nonempty (↑(sᶜ) ≃ ↑(range ↑fᶜ))

tactic: rw [← lift_mk_eq.{u, v, max u v}, mk_compl_eq_mk_compl_finite_lift.{u, v, max u v} h]
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift (#α) = lift (#β)
g : α ≃ β
⊢ Nonempty (↑(sᶜ) ≃ ↑(range ↑fᶜ))

tactic: rw [mk_range_eq_lift.{u, v, max u v}]
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift (#α) = lift (#β)
g : α ≃ β
⊢ lift (#↑s) = lift (#↑(range ↑f))

tactic: exact f.2
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift (#α) = lift (#β)
g : α ≃ β
⊢ Injective ↑f
Theorem: FreeGroup.Red.Step.sublist
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: cases H
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
H : Step L₁ L₂
⊢ L₂ <+ L₁

tactic: simp
state_before: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₁✝ ++ L₂✝ <+ L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝

tactic: constructor
state_before: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, b✝) :: (x✝, !b✝) :: L₂✝

tactic: constructor
state_before: case not.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, !b✝) :: L₂✝

tactic: rfl
state_before: case not.a.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ L₂✝
Theorem: Finset.Nat.antidiagonal.fst_le
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: rw [le_iff_exists_add]
state_before: n : ℕ
kl : ℕ × ℕ
hlk : kl ∈ antidiagonal n
⊢ kl.fst ≤ n

tactic: use kl.2
state_before: n : ℕ
kl : ℕ × ℕ
hlk : kl ∈ antidiagonal n
⊢ ∃ c, n = kl.fst + c

tactic: rwa [mem_antidiagonal, eq_comm] at hlk
state_before: n : ℕ
kl : ℕ × ℕ
hlk : kl ∈ antidiagonal n
⊢ n = kl.fst + kl.snd
Theorem: CategoryTheory.Abelian.imageIsoImage_hom_comp_image_ι
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp only [IsImage.isoExt_hom, IsImage.lift_ι, imageStrongEpiMonoFactorisation_m]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (imageIsoImage f).hom ≫ Limits.image.ι f = kernel.ι (cokernel.π f)
Theorem: unitary.coe_zpow
File: Mathlib/Algebra/Star/Unitary.lean

tactic: induction z
state_before: R : Type u_1
inst✝¹ : GroupWithZero R
inst✝ : StarSemigroup R
U : { x // x ∈ unitary R }
z : ℤ
⊢ ↑(U ^ z) = ↑U ^ z

tactic: simp [SubmonoidClass.coe_pow]
state_before: case ofNat
R : Type u_1
inst✝¹ : GroupWithZero R
inst✝ : StarSemigroup R
U : { x // x ∈ unitary R }
a✝ : ℕ
⊢ ↑(U ^ Int.ofNat a✝) = ↑U ^ Int.ofNat a✝

tactic: simp [coe_inv]
state_before: case negSucc
R : Type u_1
inst✝¹ : GroupWithZero R
inst✝ : StarSemigroup R
U : { x // x ∈ unitary R }
a✝ : ℕ
⊢ ↑(U ^ Int.negSucc a✝) = ↑U ^ Int.negSucc a✝
Theorem: GeneralizedContinuedFraction.part_num_eq_s_a
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [partialNumerators, s_nth_eq]
state_before: α : Type u_1
g : GeneralizedContinuedFraction α
n : ℕ
gp : Pair α
s_nth_eq : Stream'.Seq.get? g.s n = some gp
⊢ Stream'.Seq.get? (partialNumerators g) n = some gp.a
Theorem: Seminorm.comp_smul
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [comp_apply, smul_apply, LinearMap.smul_apply, map_smul_eq_mul, NNReal.smul_def, coe_nnnorm,
  smul_eq_mul, comp_apply]
state_before: R : Type ?u.552397
R' : Type ?u.552400
𝕜 : Type u_3
𝕜₂ : Type u_1
𝕜₃ : Type ?u.552409
𝕝 : Type ?u.552412
E : Type u_4
E₂ : Type u_2
E₃ : Type ?u.552421
F : Type ?u.552424
G : Type ?u.552427
ι : Type ?u.552430
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : SeminormedCommRing 𝕜₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝⁴ : RingHomIsometric σ₁₂
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜₂ E₂
p : Seminorm 𝕜₂ E₂
f : E →ₛₗ[σ₁₂] E₂
c : 𝕜₂
x✝ : E
⊢ ↑(comp p (c • f)) x✝ = ↑(‖c‖₊ • comp p f) x✝
Theorem: MvPolynomial.weightedHomogeneousComponent_finsupp
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

tactic: suffices
  (Function.support fun m => weightedHomogeneousComponent w m φ) ⊆
    (fun d => weightedDegree' w d) '' φ.support by
  exact Finite.subset ((fun d : σ →₀ ℕ => (weightedDegree' w) d) '' ↑(support φ)).toFinite this
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
⊢ Set.Finite (Function.support fun m => ↑(weightedHomogeneousComponent w m) φ)

tactic: intro m hm
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
⊢ (Function.support fun m => ↑(weightedHomogeneousComponent w m) φ) ⊆ (fun d => ↑(weightedDegree' w) d) '' ↑(support φ)

tactic: by_contra hm'
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
m : M
hm : m ∈ Function.support fun m => ↑(weightedHomogeneousComponent w m) φ
⊢ m ∈ (fun d => ↑(weightedDegree' w) d) '' ↑(support φ)

tactic: apply hm
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
m : M
hm : m ∈ Function.support fun m => ↑(weightedHomogeneousComponent w m) φ
hm' : ¬m ∈ (fun d => ↑(weightedDegree' w) d) '' ↑(support φ)
⊢ False

tactic: simp only [mem_support, Ne.def] at hm
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
m : M
hm : m ∈ Function.support fun m => ↑(weightedHomogeneousComponent w m) φ
hm' : ¬m ∈ (fun d => ↑(weightedDegree' w) d) '' ↑(support φ)
⊢ (fun m => ↑(weightedHomogeneousComponent w m) φ) m = 0

tactic: simp only [Set.mem_image, not_exists, not_and] at hm'
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
m : M
hm' : ¬m ∈ (fun d => ↑(weightedDegree' w) d) '' ↑(support φ)
hm : ¬↑(weightedHomogeneousComponent w m) φ = 0
⊢ (fun m => ↑(weightedHomogeneousComponent w m) φ) m = 0

tactic: exact weightedHomogeneousComponent_eq_zero' m φ hm'
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
m : M
hm : ¬↑(weightedHomogeneousComponent w m) φ = 0
hm' : ∀ (x : σ →₀ ℕ), x ∈ ↑(support φ) → ¬↑(weightedDegree' w) x = m
⊢ (fun m => ↑(weightedHomogeneousComponent w m) φ) m = 0

tactic: exact Finite.subset ((fun d : σ →₀ ℕ => (weightedDegree' w) d) '' ↑(support φ)).toFinite this
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
this :
  (Function.support fun m => ↑(weightedHomogeneousComponent w m) φ) ⊆ (fun d => ↑(weightedDegree' w) d) '' ↑(support φ)
⊢ Set.Finite (Function.support fun m => ↑(weightedHomogeneousComponent w m) φ)
Theorem: orderOf_inv
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simp [orderOf_eq_orderOf_iff]
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
x : G
⊢ orderOf x⁻¹ = orderOf x
Theorem: List.erase_of_not_mem
File: Std/Data/List/Lemmas.lean

tactic: rw [mem_cons, not_or] at h
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : ¬a ∈ b :: l
⊢ List.erase (b :: l) a = b :: l

tactic: rw [erase_cons, if_neg (Ne.symm h.1), erase_of_not_mem h.2]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : ¬a = b ∧ ¬a ∈ l
⊢ List.erase (b :: l) a = b :: l
Theorem: Matrix.cramer_row_self
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: rw [← transpose_transpose A, det_transpose]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ ↑(cramer A) b = Pi.single i (det A)

tactic: convert cramer_transpose_row_self Aᵀ i
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ ↑(cramer Aᵀᵀ) b = Pi.single i (det Aᵀ)

tactic: exact funext h
state_before: case h.e'_2.h.e'_6
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ b = Aᵀ i
Theorem: NNReal.tsum_eq_toNNReal_tsum
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: by_cases h : Summable f
state_before: α : Type ?u.309286
β : Type u_1
γ : Type ?u.309292
f : β → ℝ≥0
⊢ (∑' (b : β), f b) = ENNReal.toNNReal (∑' (b : β), ↑(f b))

tactic: rw [← ENNReal.coe_tsum h, ENNReal.toNNReal_coe]
state_before: case pos
α : Type ?u.309286
β : Type u_1
γ : Type ?u.309292
f : β → ℝ≥0
h : Summable f
⊢ (∑' (b : β), f b) = ENNReal.toNNReal (∑' (b : β), ↑(f b))

tactic: have A := tsum_eq_zero_of_not_summable h
state_before: case neg
α : Type ?u.309286
β : Type u_1
γ : Type ?u.309292
f : β → ℝ≥0
h : ¬Summable f
⊢ (∑' (b : β), f b) = ENNReal.toNNReal (∑' (b : β), ↑(f b))

tactic: simp only [← ENNReal.tsum_coe_ne_top_iff_summable, Classical.not_not] at h
state_before: case neg
α : Type ?u.309286
β : Type u_1
γ : Type ?u.309292
f : β → ℝ≥0
h : ¬Summable f
A : (∑' (b : β), f b) = 0
⊢ (∑' (b : β), f b) = ENNReal.toNNReal (∑' (b : β), ↑(f b))

tactic: simp only [h, ENNReal.top_toNNReal, A]
state_before: case neg
α : Type ?u.309286
β : Type u_1
γ : Type ?u.309292
f : β → ℝ≥0
A : (∑' (b : β), f b) = 0
h : (∑' (b : β), ↑(f b)) = ⊤
⊢ (∑' (b : β), f b) = ENNReal.toNNReal (∑' (b : β), ↑(f b))
Theorem: MeasurableEmbedding.aemeasurable_map_iff
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: refine' ⟨fun H => H.comp_measurable hf.measurable, _⟩
state_before: ι : Type ?u.3357463
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.3357475
R : Type ?u.3357478
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g✝ : α → β
μ ν : MeasureTheory.Measure α
g : β → γ
hf : MeasurableEmbedding f
⊢ AEMeasurable g ↔ AEMeasurable (g ∘ f)

tactic: rintro ⟨g₁, hgm₁, heq⟩
state_before: ι : Type ?u.3357463
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.3357475
R : Type ?u.3357478
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g✝ : α → β
μ ν : MeasureTheory.Measure α
g : β → γ
hf : MeasurableEmbedding f
⊢ AEMeasurable (g ∘ f) → AEMeasurable g

tactic: rcases hf.exists_measurable_extend hgm₁ fun x => ⟨g x⟩ with ⟨g₂, hgm₂, rfl⟩
state_before: case intro.intro
ι : Type ?u.3357463
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.3357475
R : Type ?u.3357478
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g✝ : α → β
μ ν : MeasureTheory.Measure α
g : β → γ
hf : MeasurableEmbedding f
g₁ : α → γ
hgm₁ : Measurable g₁
heq : g ∘ f =ᶠ[ae μ] g₁
⊢ AEMeasurable g

tactic: exact ⟨g₂, hgm₂, hf.ae_map_iff.2 heq⟩
state_before: case intro.intro.intro.intro
ι : Type ?u.3357463
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.3357475
R : Type ?u.3357478
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g✝ : α → β
μ ν : MeasureTheory.Measure α
g : β → γ
hf : MeasurableEmbedding f
g₂ : β → γ
hgm₂ : Measurable g₂
hgm₁ : Measurable (g₂ ∘ f)
heq : g ∘ f =ᶠ[ae μ] g₂ ∘ f
⊢ AEMeasurable g
Theorem: continuous_pow
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: simpa using continuous_const
state_before: ι : Type ?u.177283
α : Type ?u.177286
X : Type ?u.177289
M : Type u_1
N : Type ?u.177295
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
⊢ Continuous fun a => a ^ 0

tactic: simp only [pow_succ]
state_before: ι : Type ?u.177283
α : Type ?u.177286
X : Type ?u.177289
M : Type u_1
N : Type ?u.177295
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a ^ (k + 1)

tactic: exact continuous_id.mul (continuous_pow _)
state_before: ι : Type ?u.177283
α : Type ?u.177286
X : Type ?u.177289
M : Type u_1
N : Type ?u.177295
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a * a ^ k
Theorem: intervalIntegral.measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa using
  measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae hab stronglyMeasurableAt_bot
    hmeas ((tendsto_bot : Tendsto _ ⊥ (𝓝 (0 : E))).mono_left inf_le_left) hf
    (tendsto_const_pure : Tendsto _ _ (pure a)) tendsto_const_pure hu hv
state_before: ι : Type u_2
𝕜 : Type ?u.1353399
E : Type u_1
F : Type ?u.1353405
A : Type ?u.1353408
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedSpace ℝ E
f : ℝ → E
a b : ℝ
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
μ : MeasureTheory.Measure ℝ
u v ua va ub vb : ι → ℝ
inst✝² : FTCFilter a la la'
inst✝¹ : FTCFilter b lb lb'
inst✝ : IsLocallyFiniteMeasure μ
hab : IntervalIntegrable f μ a b
hmeas : StronglyMeasurableAtFilter f lb'
hf : Tendsto f (lb' ⊓ Measure.ae μ) (𝓝 c)
hu : Tendsto u lt lb
hv : Tendsto v lt lb
⊢ (fun t => ((∫ (x : ℝ) in a..v t, f x ∂μ) - ∫ (x : ℝ) in a..u t, f x ∂μ) - ∫ (x : ℝ) in u t..v t, c ∂μ) =o[lt] fun t =>
    ∫ (x : ℝ) in u t..v t, 1 ∂μ
Theorem: Module.DirectLimit.lift_unique
File: Mathlib/Algebra/DirectLimit.lean

tactic: rw [LinearMap.comp_apply, of_f]
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : (i : ι) → AddCommGroup (G i)
inst✝⁴ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
P : Type u₁
inst✝³ : AddCommGroup P
inst✝² : Module R P
g : (i : ι) → G i →ₗ[R] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑(g j) (↑(f i j hij) x) = ↑(g i) x
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
F : DirectLimit G f →ₗ[R] P
x✝ : DirectLimit G f
i j : ι
hij : i ≤ j
x : G i
⊢ ↑((fun i => LinearMap.comp F (of R ι G f i)) j) (↑(f i j hij) x) = ↑((fun i => LinearMap.comp F (of R ι G f i)) i) x

tactic: rfl
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : (i : ι) → AddCommGroup (G i)
inst✝⁴ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
P : Type u₁
inst✝³ : AddCommGroup P
inst✝² : Module R P
g : (i : ι) → G i →ₗ[R] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑(g j) (↑(f i j hij) x) = ↑(g i) x
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
F : DirectLimit G f →ₗ[R] P
x✝ : DirectLimit G f
i j : ι
hij : i ≤ j
x : G i
⊢ ↑F (↑(of R ι G f i) x) = ↑((fun i => LinearMap.comp F (of R ι G f i)) i) x

tactic: rw [lift_of]
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : (i : ι) → AddCommGroup (G i)
inst✝⁴ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
P : Type u₁
inst✝³ : AddCommGroup P
inst✝² : Module R P
g : (i : ι) → G i →ₗ[R] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑(g j) (↑(f i j hij) x) = ↑(g i) x
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
F : DirectLimit G f →ₗ[R] P
x✝ : DirectLimit G f
i : ι
x : G i
⊢ ↑F (↑(of R ι G f i) x) =
    ↑(lift R ι G f (fun i => LinearMap.comp F (of R ι G f i))
          (_ :
            ∀ (i j : ι) (hij : i ≤ j) (x : G i),
              ↑((fun i => LinearMap.comp F (of R ι G f i)) j) (↑(f i j hij) x) =
                ↑((fun i => LinearMap.comp F (of R ι G f i)) i) x))
      (↑(of R ι G f i) x)

tactic: rfl
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : (i : ι) → AddCommGroup (G i)
inst✝⁴ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
P : Type u₁
inst✝³ : AddCommGroup P
inst✝² : Module R P
g : (i : ι) → G i →ₗ[R] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), ↑(g j) (↑(f i j hij) x) = ↑(g i) x
inst✝¹ : Nonempty ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
F : DirectLimit G f →ₗ[R] P
x✝ : DirectLimit G f
i : ι
x : G i
⊢ ↑F (↑(of R ι G f i) x) = ↑(LinearMap.comp F (of R ι G f i)) x