1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.cons_dotProduct
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 α
x : α
v : Fin n → α
w : Fin n.succ → α
⊢ vecCons x v ⬝ᵥ w = x * vecHead w + v ⬝ᵥ vecTail w
state_after: no goals
Theorem: MeasureTheory.measure_inv_null
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: refine ⟨fun hs => ?_, (quasiMeasurePreserving_inv μ).preimage_null⟩
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ μ s⁻¹ = 0 ↔ μ s = 0
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
hs : μ s⁻¹ = 0
⊢ μ s = 0

tactic: rw [← inv_inv s]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
hs : μ s⁻¹ = 0
⊢ μ s = 0
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
hs : μ s⁻¹ = 0
⊢ μ s⁻¹⁻¹ = 0

tactic: exact (quasiMeasurePreserving_inv μ).preimage_null hs
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
hs : μ s⁻¹ = 0
⊢ μ s⁻¹⁻¹ = 0
state_after: no goals
Theorem: SetTheory.PGame.grundyValue_eq_mex_right
File: Mathlib/SetTheory/Game/Nim.lean

tactic: rw [← grundyValue_neg, grundyValue_eq_mex_left]
state_before: l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
⊢ (mk l r L R).grundyValue = mex fun i => ((mk l r L R).moveRight i).grundyValue
state_after: l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
⊢ (mex fun i => ((-mk l r L R).moveLeft i).grundyValue) = mex fun i => ((mk l r L R).moveRight i).grundyValue

tactic: congr
state_before: l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
⊢ (mex fun i => ((-mk l r L R).moveLeft i).grundyValue) = mex fun i => ((mk l r L R).moveRight i).grundyValue
state_after: case e_f
l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
⊢ (fun i => ((-mk l r L R).moveLeft i).grundyValue) = fun i => ((mk l r L R).moveRight i).grundyValue

tactic: ext i
state_before: case e_f
l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
⊢ (fun i => ((-mk l r L R).moveLeft i).grundyValue) = fun i => ((mk l r L R).moveRight i).grundyValue
state_after: case e_f.h
l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
i : (-mk l r L R).LeftMoves
⊢ ((-mk l r L R).moveLeft i).grundyValue = ((mk l r L R).moveRight i).grundyValue

tactic: haveI : (R i).Impartial := @Impartial.moveRight_impartial ⟨l, r, L, R⟩ _ i
state_before: case e_f.h
l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
i : (-mk l r L R).LeftMoves
⊢ ((-mk l r L R).moveLeft i).grundyValue = ((mk l r L R).moveRight i).grundyValue
state_after: case e_f.h
l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
i : (-mk l r L R).LeftMoves
this : (R i).Impartial
⊢ ((-mk l r L R).moveLeft i).grundyValue = ((mk l r L R).moveRight i).grundyValue

tactic: apply grundyValue_neg
state_before: case e_f.h
l r : Type u
L : l → PGame
R : r → PGame
x✝ : (mk l r L R).Impartial
i : (-mk l r L R).LeftMoves
this : (R i).Impartial
⊢ ((-mk l r L R).moveLeft i).grundyValue = ((mk l r L R).moveRight i).grundyValue
state_after: no goals
Theorem: MeasureTheory.lintegral_dirac'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [lintegral_congr_ae (ae_eq_dirac' hf)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace α
a : α
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (a : α), f a ∂dirac a = f a
state_after: no goals
Theorem: Finset.centroid_univ
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [centroid, centroid, ← s.attach_affineCombination_coe]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
⊢ centroid k univ Subtype.val = centroid k s id
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
⊢ (affineCombination k univ Subtype.val) (centroidWeights k univ) =
    (affineCombination k s.attach Subtype.val) (centroidWeights k s ∘ Subtype.val)

tactic: congr
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
⊢ (affineCombination k univ Subtype.val) (centroidWeights k univ) =
    (affineCombination k s.attach Subtype.val) (centroidWeights k s ∘ Subtype.val)
state_after: case h.e_6.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
⊢ centroidWeights k univ = centroidWeights k s ∘ Subtype.val

tactic: ext
state_before: case h.e_6.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
⊢ centroidWeights k univ = centroidWeights k s ∘ Subtype.val
state_after: case h.e_6.h.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
x✝ : { x // x ∈ s }
⊢ centroidWeights k univ x✝ = (centroidWeights k s ∘ Subtype.val) x✝

tactic: simp
state_before: case h.e_6.h.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset P
x✝ : { x // x ∈ s }
⊢ centroidWeights k univ x✝ = (centroidWeights k s ∘ Subtype.val) x✝
state_after: no goals
Theorem: integrable_mul_exp_neg_mul_sq
File: Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean

tactic: simpa using integrable_rpow_mul_exp_neg_mul_sq hb (by norm_num : (-1 : ℝ) < 1)
state_before: b : ℝ
hb : 0 < b
⊢ Integrable (fun x => x * rexp (-b * x ^ 2)) volume
state_after: no goals

tactic: norm_num
state_before: b : ℝ
hb : 0 < b
⊢ -1 < 1
state_after: no goals
Theorem: Matroid.coindep_iff_subset_compl_base
File: Mathlib/Data/Matroid/Dual.lean

tactic: simp_rw [coindep_iff_exists', subset_diff]
state_before: α : Type u_1
M : Matroid α
I B X : Set α
⊢ M.Coindep X ↔ ∃ B, M.Base B ∧ X ⊆ M.E \ B
state_after: α : Type u_1
M : Matroid α
I B X : Set α
⊢ (∃ B, M.Base B ∧ B ⊆ M.E ∧ Disjoint B X) ∧ X ⊆ M.E ↔ ∃ B, M.Base B ∧ X ⊆ M.E ∧ Disjoint X B

tactic: exact ⟨fun ⟨⟨B, hB, _, hBX⟩, hX⟩ ↦ ⟨B, hB, hX, hBX.symm⟩,
  fun ⟨B, hB, hXE, hXB⟩ ↦ ⟨⟨B, hB, hB.subset_ground,  hXB.symm⟩, hXE⟩⟩
state_before: α : Type u_1
M : Matroid α
I B X : Set α
⊢ (∃ B, M.Base B ∧ B ⊆ M.E ∧ Disjoint B X) ∧ X ⊆ M.E ↔ ∃ B, M.Base B ∧ X ⊆ M.E ∧ Disjoint X B
state_after: no goals
Theorem: Nat.left_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: simpa using unpair_left_le (pair a b)
state_before: a b : ℕ
⊢ a ≤ pair a b
state_after: no goals
Theorem: DFinsupp.add_eq_zero_iff
File: Mathlib/Data/DFinsupp/Order.lean

tactic: simp [DFunLike.ext_iff, forall_and]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → CanonicallyOrderedAddCommMonoid (α i)
f g : Π₀ (i : ι), α i
⊢ f + g = 0 ↔ f = 0 ∧ g = 0
state_after: no goals
Theorem: abs_le_one_iff_mul_self_le_one
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: simpa only [abs_one, one_mul] using @abs_le_iff_mul_self_le α _ a 1
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
⊢ |a| ≤ 1 ↔ a * a ≤ 1
state_after: no goals
Theorem: Option.map_map₂_antidistrib
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_antidistrib]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g₁ b) (Option.map g₂ a)
state_after: no goals
Theorem: Finset.image₂_singleton_inter
File: Mathlib/Data/Finset/NAry.lean

tactic: simp_rw [image₂_singleton_left, image_inter _ _ hf]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
t₁ t₂ : Finset β
hf : Injective (f a)
⊢ image₂ f {a} (t₁ ∩ t₂) = image₂ f {a} t₁ ∩ image₂ f {a} t₂
state_after: no goals
Theorem: Polynomial.map_natDegree_eq_natDegree
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: simpa
state_before: R : Type u_1
inst✝³ : Semiring R
f : R[X]
S : Type u_2
F : Type u_3
inst✝² : Semiring S
inst✝¹ : FunLike F R[X] S[X]
inst✝ : AddMonoidHomClass F R[X] S[X]
φ : F
p : R[X]
φ_mon_nat : ∀ (n : ℕ) (c : R), c ≠ 0 → (φ ((monomial n) c)).natDegree = n
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → (φ ((monomial n) c)).natDegree = n - 0
state_after: no goals
Theorem: ENNReal.toNNReal_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rcases lt_trichotomy z 0 with (H | H | H)
state_before: x : ℝ≥0∞
z : ℝ
⊢ x.toNNReal ^ z = (x ^ z).toNNReal
state_after: case inl
x : ℝ≥0∞
z : ℝ
H : z < 0
⊢ x.toNNReal ^ z = (x ^ z).toNNReal

case inr.inl
x : ℝ≥0∞
z : ℝ
H : z = 0
⊢ x.toNNReal ^ z = (x ^ z).toNNReal

case inr.inr
x : ℝ≥0∞
z : ℝ
H : 0 < z
⊢ x.toNNReal ^ z = (x ^ z).toNNReal

tactic: cases' x with x
state_before: case inl
x : ℝ≥0∞
z : ℝ
H : z < 0
⊢ x.toNNReal ^ z = (x ^ z).toNNReal
state_after: case inl.top
z : ℝ
H : z < 0
⊢ ⊤.toNNReal ^ z = (⊤ ^ z).toNNReal

case inl.coe
z : ℝ
H : z < 0
x : ℝ≥0
⊢ (↑x).toNNReal ^ z = (↑x ^ z).toNNReal

tactic: by_cases hx : x = 0
state_before: case inl.coe
z : ℝ
H : z < 0
x : ℝ≥0
⊢ (↑x).toNNReal ^ z = (↑x ^ z).toNNReal
state_after: case pos
z : ℝ
H : z < 0
x : ℝ≥0
hx : x = 0
⊢ (↑x).toNNReal ^ z = (↑x ^ z).toNNReal

case neg
z : ℝ
H : z < 0
x : ℝ≥0
hx : ¬x = 0
⊢ (↑x).toNNReal ^ z = (↑x ^ z).toNNReal

tactic: simp [H, ne_of_lt]
state_before: case inl.top
z : ℝ
H : z < 0
⊢ ⊤.toNNReal ^ z = (⊤ ^ z).toNNReal
state_after: no goals

tactic: simp [hx, H, ne_of_lt]
state_before: case pos
z : ℝ
H : z < 0
x : ℝ≥0
hx : x = 0
⊢ (↑x).toNNReal ^ z = (↑x ^ z).toNNReal
state_after: no goals

tactic: simp [coe_rpow_of_ne_zero hx]
state_before: case neg
z : ℝ
H : z < 0
x : ℝ≥0
hx : ¬x = 0
⊢ (↑x).toNNReal ^ z = (↑x ^ z).toNNReal
state_after: no goals

tactic: simp [H]
state_before: case inr.inl
x : ℝ≥0∞
z : ℝ
H : z = 0
⊢ x.toNNReal ^ z = (x ^ z).toNNReal
state_after: no goals

tactic: cases x
state_before: case inr.inr
x : ℝ≥0∞
z : ℝ
H : 0 < z
⊢ x.toNNReal ^ z = (x ^ z).toNNReal
state_after: case inr.inr.top
z : ℝ
H : 0 < z
⊢ ⊤.toNNReal ^ z = (⊤ ^ z).toNNReal

case inr.inr.coe
z : ℝ
H : 0 < z
x✝ : ℝ≥0
⊢ (↑x✝).toNNReal ^ z = (↑x✝ ^ z).toNNReal

tactic: simp [coe_rpow_of_nonneg _ (le_of_lt H)]
state_before: case inr.inr.coe
z : ℝ
H : 0 < z
x✝ : ℝ≥0
⊢ (↑x✝).toNNReal ^ z = (↑x✝ ^ z).toNNReal
state_after: no goals

tactic: simp [H, ne_of_gt]
state_before: case inr.inr.top
z : ℝ
H : 0 < z
⊢ ⊤.toNNReal ^ z = (⊤ ^ z).toNNReal
state_after: no goals
Theorem: NNReal.rpow_add_rpow_le_add
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: rw [← @NNReal.le_rpow_one_div_iff _ _ (1 / p) (by simp [lt_of_lt_of_le zero_lt_one hp1])]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ (a ^ p + b ^ p) ^ (1 / p) ≤ a + b
state_after: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ (1 / (1 / p))

tactic: rw [one_div_one_div]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ (1 / (1 / p))
state_after: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p

tactic: exact add_rpow_le_rpow_add _ _ hp1
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ a ^ p + b ^ p ≤ (a + b) ^ p
state_after: no goals

tactic: simp [lt_of_lt_of_le zero_lt_one hp1]
state_before: ι : Type u
s : Finset ι
p : ℝ
a b : ℝ≥0
hp1 : 1 ≤ p
⊢ 0 < 1 / p
state_after: no goals
Theorem: AkraBazziRecurrence.GrowsPolynomially.pow
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

tactic: simp_rw [← rpow_natCast]
state_before: f : ℝ → ℝ
p : ℕ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ p
state_after: f : ℝ → ℝ
p : ℕ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ ↑p

tactic: exact hf.rpow p hf_nonneg
state_before: f : ℝ → ℝ
p : ℕ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ ↑p
state_after: no goals
Theorem: stoneCechExtend_extends
File: Mathlib/Topology/StoneCech.lean

tactic: ext x
state_before: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
⊢ stoneCechExtend hg ∘ stoneCechUnit = g
state_after: case h
α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
x : α
⊢ (stoneCechExtend hg ∘ stoneCechUnit) x = g x

tactic: rw [stoneCechExtend, Function.comp_apply, stoneCechUnit, t2Quotient.lift_mk]
state_before: case h
α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
x : α
⊢ (stoneCechExtend hg ∘ stoneCechUnit) x = g x
state_after: case h
α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
x : α
⊢ preStoneCechExtend hg (preStoneCechUnit x) = g x

tactic: apply congrFun (preStoneCechExtend_extends hg)
state_before: case h
α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
x : α
⊢ preStoneCechExtend hg (preStoneCechUnit x) = g x
state_after: no goals
Theorem: MeasureTheory.integral_condexp_indicator
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean

tactic: rw [integral_condexp, integral_indicator hA, setIntegral_const, smul_eq_mul, mul_one]
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f g : α → F'
s : Set α
mF : MeasurableSpace F
Y : α → F
hY : Measurable Y
inst✝ : SigmaFinite (μ.trim ⋯)
A : Set α
hA : MeasurableSet A
⊢ ∫ (x : α), (μ[A.indicator fun x => 1|MeasurableSpace.comap Y mF]) x ∂μ = (μ A).toReal
state_after: no goals
Theorem: Flow.isInvariant_omegaLimit
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: refine fun t ↦ MapsTo.mono_right ?_ (omegaLimit_subset_of_tendsto ϕ s (hf t))
state_before: τ : Type u_1
inst✝³ : TopologicalSpace τ
inst✝² : AddMonoid τ
inst✝¹ : ContinuousAdd τ
α : Type u_2
inst✝ : TopologicalSpace α
f : Filter τ
ϕ : Flow τ α
s : Set α
hf : ∀ (t : τ), Tendsto (fun x => t + x) f f
⊢ IsInvariant ϕ.toFun (ω f ϕ.toFun s)
state_after: τ : Type u_1
inst✝³ : TopologicalSpace τ
inst✝² : AddMonoid τ
inst✝¹ : ContinuousAdd τ
α : Type u_2
inst✝ : TopologicalSpace α
f : Filter τ
ϕ : Flow τ α
s : Set α
hf : ∀ (t : τ), Tendsto (fun x => t + x) f f
t : τ
⊢ MapsTo (ϕ.toFun t) (ω f ϕ.toFun s) (ω f (fun t_1 x => ϕ.toFun (t + t_1) x) s)

tactic: exact
  mapsTo_omegaLimit _ (mapsTo_id _) (fun t' x ↦ (ϕ.map_add _ _ _).symm)
    (continuous_const.flow ϕ continuous_id)
state_before: τ : Type u_1
inst✝³ : TopologicalSpace τ
inst✝² : AddMonoid τ
inst✝¹ : ContinuousAdd τ
α : Type u_2
inst✝ : TopologicalSpace α
f : Filter τ
ϕ : Flow τ α
s : Set α
hf : ∀ (t : τ), Tendsto (fun x => t + x) f f
t : τ
⊢ MapsTo (ϕ.toFun t) (ω f ϕ.toFun s) (ω f (fun t_1 x => ϕ.toFun (t + t_1) x) s)
state_after: no goals
Theorem: gaussSum_sq
File: Mathlib/NumberTheory/GaussSum.lean

tactic: rw [pow_two, ← gaussSum_mul_gaussSum_eq_card hχ₁ hψ, hχ₂.inv, mul_rotate']
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ ^ 2 = χ (-1) * ↑(Fintype.card R)
state_after: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ * gaussSum χ ψ = gaussSum χ ψ * (gaussSum χ ψ⁻¹ * χ (-1))

tactic: congr
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ * gaussSum χ ψ = gaussSum χ ψ * (gaussSum χ ψ⁻¹ * χ (-1))
state_after: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ = gaussSum χ ψ⁻¹ * χ (-1)

tactic: rw [mul_comm, ← gaussSum_mulShift _ _ (-1 : Rˣ), inv_mulShift]
state_before: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ = gaussSum χ ψ⁻¹ * χ (-1)
state_after: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ χ ↑(-1) * gaussSum χ (ψ.mulShift ↑(-1)) = χ (-1) * gaussSum χ (ψ.mulShift (-1))

tactic: rfl
state_before: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ χ ↑(-1) * gaussSum χ (ψ.mulShift ↑(-1)) = χ (-1) * gaussSum χ (ψ.mulShift (-1))
state_after: no goals
Theorem: StarConvex.add
File: Mathlib/Analysis/Convex/Star.lean

tactic: rw [← add_image_prod]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + y) (s + t)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + y) ((fun x => x.1 + x.2) '' s ×ˢ t)

tactic: exact (hs.prod ht).is_linear_image IsLinearMap.isLinearMap_add
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 y t
⊢ StarConvex 𝕜 (x + y) ((fun x => x.1 + x.2) '' s ×ˢ t)
state_after: no goals
Theorem: vectorSpan_range_eq_span_range_vsub_right
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [vectorSpan_eq_span_vsub_set_right k (Set.mem_range_self i0), ← Set.range_comp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ vectorSpan k (range p) = Submodule.span k (range fun i => p i -ᵥ p i0)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x => x -ᵥ p i0) ∘ p)) = Submodule.span k (range fun i => p i -ᵥ p i0)

tactic: congr
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x => x -ᵥ p i0) ∘ p)) = Submodule.span k (range fun i => p i -ᵥ p i0)
state_after: no goals
Theorem: Cardinal.add_le_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rcases le_or_lt ℵ₀ a with ha | ha
state_before: a b : Cardinal.{u_1}
⊢ a + b ≤ max (max a b) ℵ₀
state_after: case inl
a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
⊢ a + b ≤ max (max a b) ℵ₀

case inr
a b : Cardinal.{u_1}
ha : a < ℵ₀
⊢ a + b ≤ max (max a b) ℵ₀

tactic: rw [add_eq_max ha]
state_before: case inl
a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
⊢ a + b ≤ max (max a b) ℵ₀
state_after: case inl
a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
⊢ max a b ≤ max (max a b) ℵ₀

tactic: exact le_max_left _ _
state_before: case inl
a b : Cardinal.{u_1}
ha : ℵ₀ ≤ a
⊢ max a b ≤ max (max a b) ℵ₀
state_after: no goals

tactic: rcases le_or_lt ℵ₀ b with hb | hb
state_before: case inr
a b : Cardinal.{u_1}
ha : a < ℵ₀
⊢ a + b ≤ max (max a b) ℵ₀
state_after: case inr.inl
a b : Cardinal.{u_1}
ha : a < ℵ₀
hb : ℵ₀ ≤ b
⊢ a + b ≤ max (max a b) ℵ₀

case inr.inr
a b : Cardinal.{u_1}
ha : a < ℵ₀
hb : b < ℵ₀
⊢ a + b ≤ max (max a b) ℵ₀

tactic: rw [add_comm, add_eq_max hb, max_comm]
state_before: case inr.inl
a b : Cardinal.{u_1}
ha : a < ℵ₀
hb : ℵ₀ ≤ b
⊢ a + b ≤ max (max a b) ℵ₀
state_after: case inr.inl
a b : Cardinal.{u_1}
ha : a < ℵ₀
hb : ℵ₀ ≤ b
⊢ max a b ≤ max (max a b) ℵ₀

tactic: exact le_max_left _ _
state_before: case inr.inl
a b : Cardinal.{u_1}
ha : a < ℵ₀
hb : ℵ₀ ≤ b
⊢ max a b ≤ max (max a b) ℵ₀
state_after: no goals

tactic: exact le_max_of_le_right (add_lt_aleph0 ha hb).le
state_before: case inr.inr
a b : Cardinal.{u_1}
ha : a < ℵ₀
hb : b < ℵ₀
⊢ a + b ≤ max (max a b) ℵ₀
state_after: no goals
Theorem: Sum.Lex.Ioc_inl_inl
File: Mathlib/Data/Sum/Interval.lean

tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioc (inlₗ a₁) (inlₗ a₂) = map (Embedding.inl.trans toLex.toEmbedding) (Ioc a₁ a₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioc (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ioc a₁ a₂))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioc (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ioc a₁ a₂))
state_after: no goals
Theorem: ConvexCone.salient_iff_not_flat
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: simp [Salient, Flat]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
S✝ S : ConvexCone 𝕜 E
⊢ S.Salient ↔ ¬S.Flat
state_after: no goals