tasksource/leandojo huggingface dataset:
Theorem: Finset.biUnion_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
⊢ Finset.biUnion (Finset.biUnion s f) g = Finset.biUnion s fun a => Finset.biUnion (f a) g

tactic: simp only [Finset.mem_biUnion, exists_prop]
state_before: case a
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ a✝ ∈ Finset.biUnion (Finset.biUnion s f) g ↔ a✝ ∈ Finset.biUnion s fun a => Finset.biUnion (f a) g

tactic: simp_rw [← exists_and_right, ← exists_and_left, and_assoc]
state_before: case a
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ (∃ a, (∃ a_1, a_1 ∈ s ∧ a ∈ f a_1) ∧ a✝ ∈ g a) ↔ ∃ a, a ∈ s ∧ ∃ a_1, a_1 ∈ f a ∧ a✝ ∈ g a_1

tactic: rw [exists_comm]
state_before: case a
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝¹ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq γ
s : Finset α
f : α → Finset β
g : β → Finset γ
a✝ : γ
⊢ (∃ a x, x ∈ s ∧ a ∈ f x ∧ a✝ ∈ g a) ↔ ∃ a x, a ∈ s ∧ x ∈ f a ∧ a✝ ∈ g x
Theorem: AlgebraicGeometry.Polynomial.isOpen_imageOfDf
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean

tactic: rw [imageOfDf, setOf_exists fun i (x : PrimeSpectrum R) => coeff f i ∉ x.asIdeal]
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (imageOfDf f)

tactic: exact isOpen_iUnion fun i => isOpen_basicOpen
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (⋃ (i : ℕ), {x | ¬coeff f i ∈ x.asIdeal})
Theorem: PadicInt.toZModPow_eq_iff_ext
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: constructor
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
⊢ (∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g') ↔ g = g'

tactic: intro hg
state_before: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
⊢ (∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g') → g = g'

tactic: ext x : 1
state_before: case mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
hg : ∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g'
⊢ g = g'

tactic: apply ext_of_toZModPow.mp
state_before: case mp.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
hg : ∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g'
x : R
⊢ ↑g x = ↑g' x

tactic: intro n
state_before: case mp.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
hg : ∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g'
x : R
⊢ ∀ (n : ℕ), ↑(toZModPow n) (↑g x) = ↑(toZModPow n) (↑g' x)

tactic: show (toZModPow n).comp g x = (toZModPow n).comp g' x
state_before: case mp.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
hg : ∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g'
x : R
n : ℕ
⊢ ↑(toZModPow n) (↑g x) = ↑(toZModPow n) (↑g' x)

tactic: rw [hg n]
state_before: case mp.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
hg : ∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g'
x : R
n : ℕ
⊢ ↑(RingHom.comp (toZModPow n) g) x = ↑(RingHom.comp (toZModPow n) g') x

tactic: rintro rfl _
state_before: case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g g' : R →+* ℤ_[p]
⊢ g = g' → ∀ (n : ℕ), RingHom.comp (toZModPow n) g = RingHom.comp (toZModPow n) g'

tactic: rfl
state_before: case mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
g : R →+* ℤ_[p]
n✝ : ℕ
⊢ RingHom.comp (toZModPow n✝) g = RingHom.comp (toZModPow n✝) g
Theorem: Ordnode.Valid'.rotateL_lemma₁
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: linarith
state_before: α : Type ?u.305831
inst✝ : Preorder α
a b c : ℕ
H2 : 3 * a ≤ b + c
hb₂ : c ≤ 3 * b
⊢ a ≤ 3 * b
Theorem: xor_iff_iff_not
File: Mathlib/Logic/Basic.lean

tactic: simp only [← @xor_not_right a, not_not]
state_before: a b : Prop
⊢ Xor' a b ↔ (a ↔ ¬b)
Theorem: FreeGroup.Red.Step.append_right
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: simp
state_before: α : Type u
L L₁ L₂ L₃ L₄ x✝¹ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ Step (L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝ ++ x✝¹) (L₁✝ ++ L₂✝ ++ x✝¹)
Theorem: QuaternionAlgebra.self_add_star'
File: Mathlib/Algebra/Quaternion.lean

tactic: ext <;> simp [two_mul]
state_before: S : Type ?u.308044
T : Type ?u.308047
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a + star a = ↑(2 * a.re)
Theorem: CategoryTheory.GrothendieckTopology.diagramNatTrans_zero
File: Mathlib/CategoryTheory/Sites/Plus.lean

tactic: ext : 2
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : Preadditive D
X : C
P Q : Cᵒᵖ ⥤ D
⊢ diagramNatTrans J 0 X = 0

tactic: refine' Multiequalizer.hom_ext _ _ _ (fun i => _)
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : Preadditive D
X : C
P Q : Cᵒᵖ ⥤ D
x✝ : (Cover J X)ᵒᵖ
⊢ (diagramNatTrans J 0 X).app x✝ = 0.app x✝

tactic: dsimp
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : Preadditive D
X : C
P Q : Cᵒᵖ ⥤ D
x✝ : (Cover J X)ᵒᵖ
i : (Cover.index x✝.unop Q).L
⊢ (diagramNatTrans J 0 X).app x✝ ≫ Multiequalizer.ι (Cover.index x✝.unop Q) i =
    0.app x✝ ≫ Multiequalizer.ι (Cover.index x✝.unop Q) i

tactic: rw [zero_comp, Multiequalizer.lift_ι, comp_zero]
state_before: case w.h
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : Preadditive D
X : C
P Q : Cᵒᵖ ⥤ D
x✝ : (Cover J X)ᵒᵖ
i : (Cover.index x✝.unop Q).L
⊢ Multiequalizer.lift (Cover.index x✝.unop Q) (multiequalizer (Cover.index x✝.unop P))
        (fun i => Multiequalizer.ι (Cover.index x✝.unop P) i ≫ 0)
        (_ :
          ∀ (i : (Cover.index x✝.unop Q).R),
            (fun i => Multiequalizer.ι (Cover.index x✝.unop P) i ≫ 0.app i.Y.op)
                  (MulticospanIndex.fstTo (Cover.index x✝.unop Q) i) ≫
                MulticospanIndex.fst (Cover.index x✝.unop Q) i =
              (fun i => Multiequalizer.ι (Cover.index x✝.unop P) i ≫ 0.app i.Y.op)
                  (MulticospanIndex.sndTo (Cover.index x✝.unop Q) i) ≫
                MulticospanIndex.snd (Cover.index x✝.unop Q) i) ≫
      Multiequalizer.ι (Cover.index x✝.unop Q) i =
    0 ≫ Multiequalizer.ι (Cover.index x✝.unop Q) i
Theorem: MeasureTheory.SimpleFunc.mem_restrict_range
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [← Finset.mem_coe, coe_range, coe_restrict _ hs, mem_range_indicator]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.814135
δ : Type ?u.814138
inst✝¹ : MeasurableSpace α
K : Type ?u.814144
inst✝ : Zero β
r : β
s : Set α
f : α →ₛ β
hs : MeasurableSet s
⊢ r ∈ SimpleFunc.range (restrict f s) ↔ r = 0 ∧ s ≠ univ ∨ r ∈ ↑f '' s
Theorem: IsometryEquiv.preimage_emetric_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.isometry.preimage_emetric_closedBall (h.symm x) r, h.apply_symm_apply]
state_before: ι : Type ?u.688882
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
x : β
r : ℝ≥0∞
⊢ ↑h ⁻¹' EMetric.closedBall x r = EMetric.closedBall (↑(IsometryEquiv.symm h) x) r
Theorem: TopologicalSpace.Opens.functor_obj_map_obj
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: ext
state_before: X Y : TopCat
f : X ⟶ Y
hf : IsOpenMap ((forget TopCat).map f)
U : Opens ↑Y
⊢ (IsOpenMap.functor hf).obj ((map f).obj U) = (IsOpenMap.functor hf).obj ⊤ ⊓ U

tactic: constructor
state_before: case h.h
X Y : TopCat
f : X ⟶ Y
hf : IsOpenMap ((forget TopCat).map f)
U : Opens ↑Y
x✝ : ↑Y
⊢ x✝ ∈ ↑((IsOpenMap.functor hf).obj ((map f).obj U)) ↔ x✝ ∈ ↑((IsOpenMap.functor hf).obj ⊤ ⊓ U)

tactic: rintro ⟨x, hx, rfl⟩
state_before: case h.h.mp
X Y : TopCat
f : X ⟶ Y
hf : IsOpenMap ((forget TopCat).map f)
U : Opens ↑Y
x✝ : ↑Y
⊢ x✝ ∈ ↑((IsOpenMap.functor hf).obj ((map f).obj U)) → x✝ ∈ ↑((IsOpenMap.functor hf).obj ⊤ ⊓ U)

tactic: exact ⟨⟨x, trivial, rfl⟩, hx⟩
state_before: case h.h.mp.intro.intro
X Y : TopCat
f : X ⟶ Y
hf : IsOpenMap ((forget TopCat).map f)
U : Opens ↑Y
x : (forget TopCat).obj X
hx : x ∈ ↑((map f).obj U)
⊢ (forget TopCat).map f x ∈ ↑((IsOpenMap.functor hf).obj ⊤ ⊓ U)

tactic: rintro ⟨⟨x, -, rfl⟩, hx⟩
state_before: case h.h.mpr
X Y : TopCat
f : X ⟶ Y
hf : IsOpenMap ((forget TopCat).map f)
U : Opens ↑Y
x✝ : ↑Y
⊢ x✝ ∈ ↑((IsOpenMap.functor hf).obj ⊤ ⊓ U) → x✝ ∈ ↑((IsOpenMap.functor hf).obj ((map f).obj U))

tactic: exact ⟨x, hx, rfl⟩
state_before: case h.h.mpr.intro.intro.intro
X Y : TopCat
f : X ⟶ Y
hf : IsOpenMap ((forget TopCat).map f)
U : Opens ↑Y
x : (forget TopCat).obj X
hx : (forget TopCat).map f x ∈ ↑U
⊢ (forget TopCat).map f x ∈ ↑((IsOpenMap.functor hf).obj ((map f).obj U))
Theorem: Nat.mul_ne_zero_iff
File: Std/Data/Nat/Lemmas.lean

tactic: simp [mul_eq_zero, not_or]
state_before: n m : Nat
⊢ n * m ≠ 0 ↔ n ≠ 0 ∧ m ≠ 0
Theorem: Stream'.append_stream_head_tail
File: Mathlib/Data/Stream/Init.lean

tactic: rw [cons_append_stream, nil_append_stream, Stream'.eta]
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ [head s] ++ₛ tail s = s
Theorem: Num.toZNum_inj
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases m <;> cases n <;> cases h <;> rfl
state_before: α : Type ?u.446714
m n : Num
h : toZNum m = toZNum n
⊢ m = n
Theorem: incomp_iff_eq
File: Mathlib/Init/Algebra/Classes.lean

tactic: rw [hab]
state_before: α : Type u
lt : α → α → Prop
inst✝¹ : IsTrichotomous α lt
inst✝ : IsIrrefl α lt
a b : α
hab : a = b
⊢ ¬lt a b ∧ ¬lt b a

tactic: exact ⟨irrefl_of lt b, irrefl_of lt b⟩
state_before: α : Type u
lt : α → α → Prop
inst✝¹ : IsTrichotomous α lt
inst✝ : IsIrrefl α lt
a b : α
hab : a = b
⊢ ¬lt b b ∧ ¬lt b b
Theorem: Nat.min_eq_zero_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: constructor
state_before: m n k l : ℕ
⊢ min m n = 0 ↔ m = 0 ∨ n = 0

tactic: intro h
state_before: case mp
m n k l : ℕ
⊢ min m n = 0 → m = 0 ∨ n = 0

tactic: cases' le_total m n with H H
state_before: case mp
m n k l : ℕ
h : min m n = 0
⊢ m = 0 ∨ n = 0

tactic: simpa [H] using Or.inl h
state_before: case mp.inl
m n k l : ℕ
h : min m n = 0
H : m ≤ n
⊢ m = 0 ∨ n = 0

tactic: simpa [H] using Or.inr h
state_before: case mp.inr
m n k l : ℕ
h : min m n = 0
H : n ≤ m
⊢ m = 0 ∨ n = 0

tactic: rintro (rfl | rfl) <;> simp
state_before: case mpr
m n k l : ℕ
⊢ m = 0 ∨ n = 0 → min m n = 0
Theorem: CommRingCat.subsingleton_of_isTerminal
File: Mathlib/Algebra/Category/Ring/Constructions.lean

tactic: infer_instance
state_before: X : CommRingCat
hX : IsTerminal X
⊢ Subsingleton PUnit
Theorem: EReal.add_lt_add
File: Mathlib/Data/Real/EReal.lean

tactic: rcases eq_or_ne x ⊥ with (rfl | hx)
state_before: x y z t : EReal
h1 : x < y
h2 : z < t
⊢ x + z < y + t

tactic: simp [h1, bot_le.trans_lt h2]
state_before: case inl
y z t : EReal
h2 : z < t
h1 : ⊥ < y
⊢ ⊥ + z < y + t

tactic: lift x to ℝ using ⟨h1.ne_top, hx⟩
state_before: case inr
x y z t : EReal
h1 : x < y
h2 : z < t
hx : x ≠ ⊥
⊢ x + z < y + t

tactic: calc (x : EReal) + z < x + t := add_lt_add_left_coe h2 _
_ ≤ y + t := add_le_add_right h1.le _
state_before: case inr.intro
y z t : EReal
h2 : z < t
x : ℝ
h1 : ↑x < y
hx : ↑x ≠ ⊥
⊢ ↑x + z < y + t
Theorem: Finset.Nat.prod_antidiagonal_succ'
File: Mathlib/Algebra/BigOperators/NatAntidiagonal.lean

tactic: rw [← prod_antidiagonal_swap, prod_antidiagonal_succ, ← prod_antidiagonal_swap]
state_before: M : Type u_1
N : Type ?u.4907
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ ∏ p in antidiagonal (n + 1), f p = f (n + 1, 0) * ∏ p in antidiagonal n, f (p.fst, p.snd + 1)

tactic: rfl
state_before: M : Type u_1
N : Type ?u.4907
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ f (Prod.swap (0, n + 1)) * ∏ p in antidiagonal n, f (Prod.swap ((Prod.swap p).fst + 1, (Prod.swap p).snd)) =
    f (n + 1, 0) * ∏ p in antidiagonal n, f (p.fst, p.snd + 1)
Theorem: Multiset.disjoint_map_map
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [Disjoint, @eq_comm _ (f _) (g _)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → γ
g : β → γ
s : Multiset α
t : Multiset β
⊢ Disjoint (map f s) (map g t) ↔ ∀ (a : α), a ∈ s → ∀ (b : β), b ∈ t → f a ≠ g b
Theorem: Sylow.smul_eq_of_normal
File: Mathlib/GroupTheory/Sylow.lean

tactic: simp only [Sylow.smul_eq_iff_mem_normalizer, normalizer_eq_top.mpr h, mem_top]
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
h : Normal ↑P
⊢ g • P = P
Theorem: Real.logb_neg_iff_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← @logb_one b, logb_lt_logb_iff_of_base_lt_one b_pos b_lt_one h zero_lt_one]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
h : 0 < x
⊢ logb b x < 0 ↔ 1 < x
Theorem: LinearMap.map_algebraMap_mul
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: rw [← Algebra.smul_def, ← Algebra.smul_def, map_smul]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₗ[R] B
a : A
r : R
⊢ ↑f (↑(algebraMap R A) r * a) = ↑(algebraMap R B) r * ↑f a
Theorem: LieIdeal.map_of_image
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: apply le_antisymm
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
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'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
h : ↑f '' ↑I = ↑J
⊢ map f I = J

tactic: erw [LieSubmodule.lieSpan_le, Submodule.map_coe, h]
state_before: case a
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
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'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
h : ↑f '' ↑I = ↑J
⊢ map f I ≤ J

tactic: rw [← SetLike.coe_subset_coe, ← h]
state_before: case a
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
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'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
h : ↑f '' ↑I = ↑J
⊢ J ≤ map f I

tactic: exact LieSubmodule.subset_lieSpan
state_before: case a
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
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'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
h : ↑f '' ↑I = ↑J
⊢ ↑f '' ↑I ⊆ ↑(map f I)
Theorem: Real.contDiffAt_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

tactic: exact_mod_cast h
state_before: n : ℕ∞
x : ℝ
h : cos x ≠ 0
⊢ Complex.cos ↑x ≠ 0
Theorem: Matrix.transpose_add
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.926145
m : Type u_1
n : Type u_2
o : Type ?u.926154
m' : o → Type ?u.926159
n' : o → Type ?u.926164
R : Type ?u.926167
S : Type ?u.926170
α : Type v
β : Type w
γ : Type ?u.926177
inst✝ : Add α
M N : Matrix m n α
⊢ (M + N)ᵀ = Mᵀ + Nᵀ

tactic: simp
state_before: case a.h
l : Type ?u.926145
m : Type u_1
n : Type u_2
o : Type ?u.926154
m' : o → Type ?u.926159
n' : o → Type ?u.926164
R : Type ?u.926167
S : Type ?u.926170
α : Type v
β : Type w
γ : Type ?u.926177
inst✝ : Add α
M N : Matrix m n α
i✝ : n
x✝ : m
⊢ (M + N)ᵀ i✝ x✝ = (Mᵀ + Nᵀ) i✝ x✝
Theorem: real_inner_smul_self_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [real_inner_smul_left, ← real_inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type ?u.3140024
E : Type ?u.3140027
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : F
r : ℝ
⊢ inner (r • x) x = r * (‖x‖ * ‖x‖)
Theorem: measurableSet_pi_of_nonempty
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: classical
  rcases h with ⟨f, hf⟩
  refine' ⟨fun hst i hi => _, MeasurableSet.pi hs⟩
  convert measurable_update f (a := i) hst
  rw [update_preimage_pi hi]
  exact fun j hj _ => hf j hj
state_before: α : Type ?u.147740
β : Type ?u.147743
γ : Type ?u.147746
δ : Type u_1
δ' : Type ?u.147752
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
h : Set.Nonempty (Set.pi s t)
⊢ MeasurableSet (Set.pi s t) ↔ ∀ (i : δ), i ∈ s → MeasurableSet (t i)

tactic: rcases h with ⟨f, hf⟩
state_before: α : Type ?u.147740
β : Type ?u.147743
γ : Type ?u.147746
δ : Type u_1
δ' : Type ?u.147752
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
h : Set.Nonempty (Set.pi s t)
⊢ MeasurableSet (Set.pi s t) ↔ ∀ (i : δ), i ∈ s → MeasurableSet (t i)

tactic: refine' ⟨fun hst i hi => _, MeasurableSet.pi hs⟩
state_before: case intro
α : Type ?u.147740
β : Type ?u.147743
γ : Type ?u.147746
δ : Type u_1
δ' : Type ?u.147752
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
f : (i : δ) → π i
hf : f ∈ Set.pi s t
⊢ MeasurableSet (Set.pi s t) ↔ ∀ (i : δ), i ∈ s → MeasurableSet (t i)

tactic: convert measurable_update f (a := i) hst
state_before: case intro
α : Type ?u.147740
β : Type ?u.147743
γ : Type ?u.147746
δ : Type u_1
δ' : Type ?u.147752
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
f : (i : δ) → π i
hf : f ∈ Set.pi s t
hst : MeasurableSet (Set.pi s t)
i : δ
hi : i ∈ s
⊢ MeasurableSet (t i)

tactic: rw [update_preimage_pi hi]
state_before: case h.e'_3
α : Type ?u.147740
β : Type ?u.147743
γ : Type ?u.147746
δ : Type u_1
δ' : Type ?u.147752
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
f : (i : δ) → π i
hf : f ∈ Set.pi s t
hst : MeasurableSet (Set.pi s t)
i : δ
hi : i ∈ s
⊢ t i = update f i ⁻¹' Set.pi s t

tactic: exact fun j hj _ => hf j hj
state_before: case h.e'_3
α : Type ?u.147740
β : Type ?u.147743
γ : Type ?u.147746
δ : Type u_1
δ' : Type ?u.147752
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
f : (i : δ) → π i
hf : f ∈ Set.pi s t
hst : MeasurableSet (Set.pi s t)
i : δ
hi : i ∈ s
⊢ ∀ (j : δ), j ∈ s → j ≠ i → f j ∈ t j
Theorem: Finset.union_left_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_union, or_left_comm]
state_before: α : Type u_1
β : Type ?u.147536
γ : Type ?u.147539
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ v : Finset α
a b : α
s t u : Finset α
x✝ : α
⊢ x✝ ∈ s ∪ (t ∪ u) ↔ x✝ ∈ t ∪ (s ∪ u)
Theorem: Set.iInter_iInter_eq_or_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [iInter_or, iInter_inter_distrib, iInter_iInter_eq_left]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.94856
ι : Sort ?u.94859
ι' : Sort ?u.94862
ι₂ : Sort ?u.94865
κ : ι → Sort ?u.94870
κ₁ : ι → Sort ?u.94875
κ₂ : ι → Sort ?u.94880
κ' : ι' → Sort ?u.94885
b : β
p : β → Prop
s : (x : β) → x = b ∨ p x → Set α
⊢ (⋂ (x : β) (h : x = b ∨ p x), s x h) = s b (_ : b = b ∨ p b) ∩ ⋂ (x : β) (h : p x), s x (_ : x = b ∨ p x)
Theorem: OrthonormalBasis.repr_symm_single
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: dsimp only [FunLike.coe]
state_before: ι : Type u_1
ι' : Type ?u.771553
𝕜 : Type u_2
inst✝¹⁰ : IsROrC 𝕜
E : Type u_3
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.771582
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.771600
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.771620
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : OrthonormalBasis ι 𝕜 E
i : ι
⊢ ↑(LinearIsometryEquiv.symm b.repr) (EuclideanSpace.single i 1) = ↑b i

tactic: congr!
state_before: ι : Type u_1
ι' : Type ?u.771553
𝕜 : Type u_2
inst✝¹⁰ : IsROrC 𝕜
E : Type u_3
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.771582
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.771600
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.771620
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : OrthonormalBasis ι 𝕜 E
i : ι
⊢ EquivLike.coe (LinearIsometryEquiv.symm b.repr) (EuclideanSpace.single i 1) =
    EquivLike.coe (LinearIsometryEquiv.symm b.repr) (EuclideanSpace.single i 1)
Theorem: MvPolynomial.esymm_isSymmetric
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: intro
state_before: σ : Type u_1
R : Type u_2
τ : Type ?u.175098
S : Type ?u.175101
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
⊢ IsSymmetric (esymm σ R n)

tactic: rw [rename_esymm]
state_before: σ : Type u_1
R : Type u_2
τ : Type ?u.175098
S : Type ?u.175101
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
n : ℕ
e✝ : Perm σ
⊢ ↑(rename ↑e✝) (esymm σ R n) = esymm σ R n