tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.SignedMeasure.singularPart_zero
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: refine' (eq_singularPart 0 0 VectorMeasure.MutuallySingular.zero_left _).symm
state_before: α : Type u_1
β : Type ?u.620644
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
⊢ singularPart 0 μ = 0

tactic: rw [zero_add, withDensityᵥ_zero]
state_before: α : Type u_1
β : Type ?u.620644
m : MeasurableSpace α
μ✝ ν : Measure α
s t : SignedMeasure α
μ : Measure α
⊢ 0 = 0 + withDensityᵥ μ 0
Theorem: FirstOrder.Language.Substructure.realize_formula_top
File: Mathlib/ModelTheory/ElementaryMaps.lean

tactic: rw [← Substructure.topEquiv.realize_formula φ]
state_before: L : Language
M : Type u_4
N : Type ?u.371937
P : Type ?u.371940
Q : Type ?u.371943
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
inst✝ : Structure L Q
α : Type u_1
φ : Formula L α
v : α → { x // x ∈ ⊤ }
⊢ Formula.Realize φ v ↔ Formula.Realize φ (Subtype.val ∘ v)

tactic: simp
state_before: L : Language
M : Type u_4
N : Type ?u.371937
P : Type ?u.371940
Q : Type ?u.371943
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
inst✝ : Structure L Q
α : Type u_1
φ : Formula L α
v : α → { x // x ∈ ⊤ }
⊢ Formula.Realize φ (↑topEquiv ∘ v) ↔ Formula.Realize φ (Subtype.val ∘ v)
Theorem: derivWithin_univ
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: ext
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
⊢ derivWithin f univ = deriv f

tactic: unfold derivWithin deriv
state_before: case h
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
x✝ : 𝕜
⊢ derivWithin f univ x✝ = deriv f x✝

tactic: rw [fderivWithin_univ]
state_before: case h
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
x✝ : 𝕜
⊢ ↑(fderivWithin 𝕜 f univ x✝) 1 = ↑(fderiv 𝕜 f x✝) 1
Theorem: ContinuousAffineMap.contDiff
File: Mathlib/Analysis/Calculus/AffineMap.lean

tactic: rw [f.decomp]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace 𝕜 W
n : ℕ∞
f : V →A[𝕜] W
⊢ ContDiff 𝕜 n ↑f

tactic: apply f.contLinear.contDiff.add
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace 𝕜 W
n : ℕ∞
f : V →A[𝕜] W
⊢ ContDiff 𝕜 n (↑(contLinear f) + Function.const V (↑f 0))

tactic: simp only
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace 𝕜 W
n : ℕ∞
f : V →A[𝕜] W
⊢ ContDiff 𝕜 n fun x => Function.const V (↑f 0) x

tactic: exact contDiff_const
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace 𝕜 W
n : ℕ∞
f : V →A[𝕜] W
⊢ ContDiff 𝕜 n fun x => Function.const V (↑f 0) x
Theorem: Equiv.ringEquiv_symm_apply
File: Mathlib/Logic/Equiv/TransferInstance.lean

tactic: letI := Equiv.Add e
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
⊢ Sort ?u.166819

tactic: letI := Equiv.Mul e
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
this : Add α := Equiv.Add e
⊢ Sort ?u.166819

tactic: exact (ringEquiv e).symm b = e.symm b
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
this✝ : Add α := Equiv.Add e
this : Mul α := Equiv.Mul e
⊢ Sort ?u.166819

tactic: intros
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
⊢ ↑(RingEquiv.symm (ringEquiv e)) b = ↑e.symm b

tactic: rfl
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝¹ : Add β
inst✝ : Mul β
b : β
⊢ ↑(RingEquiv.symm (ringEquiv e)) b = ↑e.symm b
Theorem: ENNReal.tsum_iSup_eq
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [h.symm]
state_before: α✝ : Type ?u.258029
β : Type ?u.258032
γ : Type ?u.258035
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
a : α
f : α → ℝ≥0∞
x✝ : α
h : x✝ ≠ a
⊢ (⨆ (_ : a = x✝), f x✝) = 0

tactic: simp
state_before: α✝ : Type ?u.258029
β : Type ?u.258032
γ : Type ?u.258035
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_1
a : α
f : α → ℝ≥0∞
⊢ (⨆ (_ : a = a), f a) = f a
Theorem: Polynomial.separable_or
File: Mathlib/FieldTheory/Separable.lean

tactic: rcases p.eq_zero_or_pos with (rfl | hp)
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F p) g = f

tactic: haveI := isLocalRingHom_expand F hp
state_before: case inr
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
hp : p > 0
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F p) g = f

tactic: exact
  Or.inr
    ⟨by rw [separable_iff_derivative_ne_zero hf, Classical.not_not, H], contract p f,
      of_irreducible_map (expand F p : F[X] →+* F[X])
        (by rwa [← expand_contract p H hp.ne'] at hf),
      expand_contract p H hp.ne'⟩
state_before: case inr
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
hp : p > 0
this : IsLocalRingHom ↑(expand F p)
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F p) g = f

tactic: haveI := CharP.charP_to_charZero F
state_before: case inl
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
HF : CharP F 0
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F 0) g = f

tactic: have := natDegree_eq_zero_of_derivative_eq_zero H
state_before: case inl
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
HF : CharP F 0
this : CharZero F
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F 0) g = f

tactic: have := (natDegree_pos_iff_degree_pos.mpr <| degree_pos_of_irreducible hf).ne'
state_before: case inl
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
HF : CharP F 0
this✝ : CharZero F
this : natDegree f = 0
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F 0) g = f

tactic: contradiction
state_before: case inl
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
HF : CharP F 0
this✝¹ : CharZero F
this✝ : natDegree f = 0
this : natDegree f ≠ 0
⊢ Separable f ∨ ¬Separable f ∧ ∃ g, Irreducible g ∧ ↑(expand F 0) g = f

tactic: rw [separable_iff_derivative_ne_zero hf, Classical.not_not, H]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
hp : p > 0
this : IsLocalRingHom ↑(expand F p)
⊢ ¬Separable f

tactic: rwa [← expand_contract p H hp.ne'] at hf
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
hf : Irreducible f
H : ↑derivative f = 0
hp : p > 0
this : IsLocalRingHom ↑(expand F p)
⊢ Irreducible (↑↑(expand F p) (contract p f))
Theorem: MeasureTheory.Content.innerContent_comap
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: refine' (Compacts.equiv f).surjective.iSup_congr _ fun K => iSup_congr_Prop image_subset_iff _
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K
U : Opens G
⊢ innerContent μ (↑(Opens.comap (Homeomorph.toContinuousMap f)) U) = innerContent μ U

tactic: intro hK
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K
U : Opens G
K : Compacts G
⊢ ↑K ⊆ ↑(↑(Opens.comap (Homeomorph.toContinuousMap f)) U) →
    (fun s => ↑(toFun μ s)) (↑(Compacts.equiv f) K) = (fun s => ↑(toFun μ s)) K

tactic: simp only [Equiv.coe_fn_mk, Subtype.mk_eq_mk, Compacts.equiv]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K
U : Opens G
K : Compacts G
hK : ↑K ⊆ ↑(↑(Opens.comap (Homeomorph.toContinuousMap f)) U)
⊢ (fun s => ↑(toFun μ s)) (↑(Compacts.equiv f) K) = (fun s => ↑(toFun μ s)) K

tactic: apply h
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(toFun μ s)) (Compacts.map ↑f (_ : Continuous ↑f) K) = (fun s => ↑(toFun μ s)) K
U : Opens G
K : Compacts G
hK : ↑K ⊆ ↑(↑(Opens.comap (Homeomorph.toContinuousMap f)) U)
⊢ ↑(toFun μ (Compacts.map ↑f (_ : Continuous ↑f) K)) = ↑(toFun μ K)
Theorem: BoxIntegral.TaggedPrepartition.distortion_unionComplToSubordinate
File: Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean

tactic: simp [unionComplToSubordinate]
state_before: ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
π₁ : TaggedPrepartition I
π₂ : Prepartition I
hU : Prepartition.iUnion π₂ = ↑I \ iUnion π₁
r : (ι → ℝ) → ↑(Ioi 0)
⊢ distortion (unionComplToSubordinate π₁ π₂ hU r) = max (distortion π₁) (Prepartition.distortion π₂)
Theorem: SimplicialObject.Splitting.IndexSet.eqId_iff_len_eq
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: rw [eqId_iff_eq]
state_before: C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ EqId A ↔ len A.fst.unop = len Δ.unop

tactic: constructor
state_before: C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ A.fst = Δ ↔ len A.fst.unop = len Δ.unop

tactic: intro h
state_before: case mp
C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ A.fst = Δ → len A.fst.unop = len Δ.unop

tactic: rw [h]
state_before: case mp
C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : A.fst = Δ
⊢ len A.fst.unop = len Δ.unop

tactic: intro h
state_before: case mpr
C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ len A.fst.unop = len Δ.unop → A.fst = Δ

tactic: rw [← unop_inj_iff]
state_before: case mpr
C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : len A.fst.unop = len Δ.unop
⊢ A.fst = Δ

tactic: ext
state_before: case mpr
C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : len A.fst.unop = len Δ.unop
⊢ A.fst.unop = Δ.unop

tactic: exact h
state_before: case mpr.a
C : Type ?u.4787
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : len A.fst.unop = len Δ.unop
⊢ len A.fst.unop = len Δ.unop
Theorem: exists_open_set_nhds'
File: Mathlib/Topology/Basic.lean

tactic: simpa using h
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s U : Set α
h : U ∈ ⨆ (x : α) (_ : x ∈ s), 𝓝 x
⊢ ∀ (x : α), x ∈ s → U ∈ 𝓝 x
Theorem: not_irreducible_one
File: Mathlib/Algebra/Associated.lean

tactic: simp [irreducible_iff]
state_before: α : Type u_1
β : Type ?u.72581
γ : Type ?u.72584
δ : Type ?u.72587
inst✝ : Monoid α
⊢ ¬Irreducible 1
Theorem: Std.RBNode.toStream_toList'
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t generalizing s <;> simp [*, toStream]
state_before: α : Type u_1
t : RBNode α
s : RBNode.Stream α
⊢ Stream.toList (toStream t s) = toList t ++ Stream.toList s
Theorem: toIcoMod_add_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIcoMod_add_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a (b + p) = toIcoMod hp a b
Theorem: Wbtw.trans_right
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [wbtw_comm] at *
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.278400
P : Type u_3
P' : Type ?u.278406
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'
w x y z : P
h₁ : Wbtw R w x z
h₂ : Wbtw R x y z
⊢ Wbtw R w y z

tactic: exact h₁.trans_left h₂
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.278400
P : Type u_3
P' : Type ?u.278406
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'
w x y z : P
h₁ : Wbtw R z x w
h₂ : Wbtw R z y x
⊢ Wbtw R z y w
Theorem: reflTransGen_of_succ_of_ge
File: Mathlib/Order/SuccPred/Relation.lean

tactic: rw [← reflTransGen_swap]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
h : ∀ (i : α), i ∈ Ico m n → r (succ i) i
hmn : m ≤ n
⊢ ReflTransGen r n m

tactic: exact reflTransGen_of_succ_of_le (swap r) h hmn
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
r : α → α → Prop
n m : α
h : ∀ (i : α), i ∈ Ico m n → r (succ i) i
hmn : m ≤ n
⊢ ReflTransGen (swap r) m n
Theorem: Nat.sInf_mem
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [Nat.sInf_def h]
state_before: s : Set ℕ
h : Set.Nonempty s
⊢ sInf s ∈ s

tactic: exact Nat.find_spec h
state_before: s : Set ℕ
h : Set.Nonempty s
⊢ Nat.find h ∈ s
Theorem: Finset.mem_insert_coe
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.106165
γ : Type ?u.106168
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b : α
s : Finset α
x y : α
⊢ x ∈ insert y s ↔ x ∈ insert y ↑s
Theorem: Behrend.map_succ
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: simp [map, Fin.sum_univ_succ, _root_.pow_succ', ← mul_assoc, ← sum_mul]
state_before: α : Type ?u.72258
β : Type ?u.72261
n d k N : ℕ
x : Fin n → ℕ
a : Fin (n + 1) → ℕ
⊢ ↑(map d) a = a 0 + (∑ x : Fin n, a (Fin.succ x) * d ^ ↑x) * d
Theorem: List.get?_set_ne
File: Std/Data/List/Lemmas.lean

tactic: simp only [set_eq_modifyNth, get?_modifyNth_ne _ _ h]
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h : m ≠ n
⊢ get? (set l m a) n = get? l n
Theorem: MeasureTheory.UniformIntegrable.ae_eq
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: obtain ⟨hfm, hunif, C, hC⟩ := hf
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hf : UniformIntegrable f p μ
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
⊢ UniformIntegrable g p μ

tactic: refine' ⟨fun i => (hfm i).congr (hfg i), (unifIntegrable_congr_ae hfg).1 hunif, C, fun i => _⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), snorm (f i) p μ ≤ ↑C
⊢ UniformIntegrable g p μ

tactic: rw [← snorm_congr_ae (hfg i)]
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), snorm (f i) p μ ≤ ↑C
i : ι
⊢ snorm (g i) p μ ≤ ↑C

tactic: exact hC i
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f g : ι → α → β
hfg : ∀ (n : ι), f n =ᵐ[μ] g n
hfm : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hunif : UnifIntegrable f p μ
C : ℝ≥0
hC : ∀ (i : ι), snorm (f i) p μ ≤ ↑C
i : ι
⊢ snorm (f i) p μ ≤ ↑C
Theorem: Int.mul_emod
File: Std/Data/Int/DivMod.lean

tactic: conv => lhs; rw [
  ← emod_add_ediv a n, ← emod_add_ediv' b n, Int.add_mul, Int.mul_add, Int.mul_add,
  Int.mul_assoc, Int.mul_assoc, ← Int.mul_add n _ _, add_mul_emod_self_left,
  ← Int.mul_assoc, add_mul_emod_self]
state_before: a b n : Int
⊢ a * b % n = a % n * (b % n) % n
Theorem: Vector.head_map
File: Mathlib/Data/Vector/Basic.lean

tactic: obtain ⟨a, v', h⟩ := Vector.exists_eq_cons v
state_before: n : ℕ
α : Type u_2
β : Type u_1
v : Vector α (n + 1)
f : α → β
⊢ head (map f v) = f (head v)

tactic: rw [h, map_cons, head_cons, head_cons]
state_before: case intro.intro
n : ℕ
α : Type u_2
β : Type u_1
v : Vector α (n + 1)
f : α → β
a : α
v' : Vector α n
h : v = a ::ᵥ v'
⊢ head (map f v) = f (head v)
Theorem: Finset.Nat.card_antidiagonal
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: simp [antidiagonal]
state_before: n : ℕ
⊢ card (antidiagonal n) = n + 1
Theorem: Fin.predAbove_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: dsimp [predAbove]
state_before: n m : ℕ
i : Fin (n + 2)
hi : i ≠ 0
⊢ predAbove 0 i = pred i hi

tactic: rw [dif_pos]
state_before: n m : ℕ
i : Fin (n + 2)
hi : i ≠ 0
⊢ (if h : ↑castSucc 0 < i then pred i (_ : i ≠ 0) else castLT i (_ : ↑i < n + 1)) = pred i hi

tactic: simp only [castSucc_zero]
state_before: case hc
n m : ℕ
i : Fin (n + 2)
hi : i ≠ 0
⊢ ↑castSucc 0 < i

tactic: exact (pos_iff_ne_zero _).mpr hi
state_before: case hc
n m : ℕ
i : Fin (n + 2)
hi : i ≠ 0
⊢ 0 < i
Theorem: InnerProductGeometry.angle_add_eq_arcsin_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle_add_eq_arccos_of_inner_eq_zero h,
  Real.arccos_eq_arcsin (div_nonneg (norm_nonneg _) (norm_nonneg _)), div_pow, one_sub_div hxy]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ angle x (x + y) = Real.arcsin (‖y‖ / ‖x + y‖)

tactic: nth_rw 1 [pow_two]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ Real.arcsin (Real.sqrt ((‖x + y‖ ^ 2 - ‖x‖ ^ 2) / ‖x + y‖ ^ 2)) = Real.arcsin (‖y‖ / ‖x + y‖)

tactic: rw [norm_add_sq_eq_norm_sq_add_norm_sq_real h, pow_two, add_sub_cancel', ← pow_two, ← div_pow,
  Real.sqrt_sq (div_nonneg (norm_nonneg _) (norm_nonneg _))]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
hxy : ‖x + y‖ ^ 2 ≠ 0
⊢ Real.arcsin (Real.sqrt ((‖x + y‖ * ‖x + y‖ - ‖x‖ ^ 2) / ‖x + y‖ ^ 2)) = Real.arcsin (‖y‖ / ‖x + y‖)

tactic: rw [pow_two, norm_add_sq_eq_norm_sq_add_norm_sq_real h, ne_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖x + y‖ ^ 2 ≠ 0

tactic: refine' ne_of_lt _
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ 0 ≠ ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

tactic: rcases h0 with (h0 | h0)
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

tactic: exact
  Left.add_pos_of_pos_of_nonneg (mul_self_pos.2 (norm_ne_zero_iff.2 h0)) (mul_self_nonneg _)
state_before: case inl
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

tactic: exact
  Left.add_pos_of_nonneg_of_pos (mul_self_nonneg _) (mul_self_pos.2 (norm_ne_zero_iff.2 h0))
state_before: case inr
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : y ≠ 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
Theorem: Filter.map_swap4_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp_rw [map_swap4_eq_comap, SProd.sprod, Filter.prod, comap_inf, comap_comap]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort ?u.23551
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
h : Filter γ
k : Filter δ
⊢ map (fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ((f ×ˢ g) ×ˢ h ×ˢ k) = (f ×ˢ h) ×ˢ g ×ˢ k

tactic: ac_rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort ?u.23551
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
h : Filter γ
k : Filter δ
⊢ comap ((Prod.fst ∘ Prod.fst) ∘ fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) f ⊓
        comap ((Prod.snd ∘ Prod.fst) ∘ fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) g ⊓
      (comap ((Prod.fst ∘ Prod.snd) ∘ fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) h ⊓
        comap ((Prod.snd ∘ Prod.snd) ∘ fun p => ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) k) =
    comap (Prod.fst ∘ Prod.fst) f ⊓ comap (Prod.snd ∘ Prod.fst) h ⊓
      (comap (Prod.fst ∘ Prod.snd) g ⊓ comap (Prod.snd ∘ Prod.snd) k)
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: simp only [hj, Fin.not_lt_zero] at H
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : ↑Fin.castSucc i < j
hj : j = 0
⊢ False

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : ↑Fin.castSucc i < j
⊢ δ X i ≫ δ X j = δ X (Fin.pred j (_ : j = 0 → False)) ≫ δ X (↑Fin.castSucc i)

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : ↑Fin.castSucc i < j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ j) =
    X.map (SimplexCategory.δ (Fin.pred j (_ : j = 0 → False))) ≫ X.map (SimplexCategory.δ (↑Fin.castSucc i))
Theorem: Submodule.map_comap_eq_self
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rwa [Submodule.map_comap_eq, inf_eq_right]
state_before: R : Type u_1
R₁ : Type ?u.1245964
R₂ : Type u_2
R₃ : Type ?u.1245970
R₄ : Type ?u.1245973
S : Type ?u.1245976
K : Type ?u.1245979
K₂ : Type ?u.1245982
M : Type u_4
M' : Type ?u.1245988
M₁ : Type ?u.1245991
M₂ : Type u_3
M₃ : Type ?u.1245997
M₄ : Type ?u.1246000
N : Type ?u.1246003
N₂ : Type ?u.1246006
ι : Type ?u.1246009
V : Type ?u.1246012
V₂ : Type ?u.1246015
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
q : Submodule R₂ M₂
h : q ≤ range f
⊢ map f (comap f q) = q