1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ProjectiveSpectrum.basicOpen_mul_le_right
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: rw [basicOpen_mul 𝒜 f g]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 (f * g) ≤ basicOpen 𝒜 g
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 f ⊓ basicOpen 𝒜 g ≤ basicOpen 𝒜 g

tactic: exact inf_le_right
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ basicOpen 𝒜 f ⊓ basicOpen 𝒜 g ≤ basicOpen 𝒜 g
state_after: no goals
Theorem: forall_imp_iff_exists_imp
File: Mathlib/Logic/Basic.lean

tactic: let ⟨a⟩ := ha
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b

tactic: refine ⟨fun h ↦ not_forall_not.1 fun h' ↦ ?_, fun ⟨x, hx⟩ h ↦ hx (h x)⟩
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
h : (∀ (x : α), p x) → b
h' : ∀ (x : α), ¬(p x → b)
⊢ False

tactic: exact if hb : b then h' a fun _ ↦ hb else hb <| h fun x ↦ (_root_.not_imp.1 (h' x)).1
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q : α✝ → Prop
α : Sort u_3
p : α → Prop
b : Prop
ha : Nonempty α
a : α
h : (∀ (x : α), p x) → b
h' : ∀ (x : α), ¬(p x → b)
⊢ False
state_after: no goals
Theorem: tendsto_comp_coe_Iio_atTop
File: Mathlib/Topology/Order/DenselyOrdered.lean

tactic: rw [← map_coe_Iio_atTop, tendsto_map'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f (𝓝[<] a) l
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l
state_after: no goals
Theorem: IntermediateField.rank_eq_one_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [← toSubalgebra_eq_iff, ← rank_eq_rank_subalgebra, Subalgebra.rank_eq_one_iff,
  bot_toSubalgebra]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ Module.rank F ↥K = 1 ↔ K = ⊥
state_after: no goals
Theorem: Nat.ofDigits_digits_append_digits
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [ofDigits_append, ofDigits_digits, ofDigits_digits]
state_before: n✝ b m n : ℕ
⊢ ofDigits b (b.digits n ++ b.digits m) = n + b ^ (b.digits n).length * m
state_after: no goals
Theorem: Submodule.linearProjOfIsCompl_apply_left
File: Mathlib/LinearAlgebra/Projection.lean

tactic: simp [linearProjOfIsCompl]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : ↥p
⊢ (p.linearProjOfIsCompl q h) ↑x = x
state_after: no goals
Theorem: hasLineDerivWithinAt_univ
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simp only [HasLineDerivWithinAt, HasLineDerivAt, preimage_univ, hasDerivWithinAt_univ]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f f₁ : E → F
f' f₀' f₁' : F
s t : Set E
x v : E
⊢ HasLineDerivWithinAt 𝕜 f f' univ x v ↔ HasLineDerivAt 𝕜 f f' x v
state_after: no goals
Theorem: Num.bit_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases b <;> cases n <;> rfl
state_before: α : Type u_1
b : Bool
n : Num
⊢ ↑(bit b n) = Nat.bit b ↑n
state_after: no goals
Theorem: YoungDiagram.rowLen_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp [rowLen, colLen]
state_before: μ : YoungDiagram
i : ℕ
⊢ μ.transpose.rowLen i = μ.colLen i
state_after: no goals
Theorem: Fin.card_fintypeIco
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: rw [← card_Ico, Fintype.card_ofFinset]
state_before: n : ℕ
a b : Fin n
⊢ Fintype.card ↑(Set.Ico a b) = ↑b - ↑a
state_after: no goals
Theorem: UniqueFactorizationMonoid.exists_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp_rw [← UniqueFactorizationMonoid.irreducible_iff_prime]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a

tactic: apply WfDvdMonoid.exists_factors a
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
state_after: no goals
Theorem: schnirelmannDensity_le_of_subset
File: Mathlib/Combinatorics/Schnirelmann.lean

tactic: positivity
state_before: A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
B : Set ℕ
inst✝ : DecidablePred fun x => x ∈ B
h : A ⊆ B
x✝¹ : ℝ
x✝ : x✝¹ ∈ Set.range fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n
w✝ : { n // 0 < n }
hx : (fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n) w✝ = x✝¹
⊢ 0 ≤ (fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n) w✝
state_after: no goals

tactic: gcongr
state_before: A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
B : Set ℕ
inst✝ : DecidablePred fun x => x ∈ B
h : A ⊆ B
x✝ : { n // 0 < n }
⊢ ↑(filter (fun x => x ∈ A) (Ioc 0 ↑x✝)).card / ↑↑x✝ ≤ ↑(filter (fun x => x ∈ B) (Ioc 0 ↑x✝)).card / ↑↑x✝
state_after: case hab.h.a
A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
B : Set ℕ
inst✝ : DecidablePred fun x => x ∈ B
h : A ⊆ B
x✝ : { n // 0 < n }
⊢ filter (fun x => x ∈ A) (Ioc 0 ↑x✝) ⊆ filter (fun x => x ∈ B) (Ioc 0 ↑x✝)

tactic: exact monotone_filter_right _ h
state_before: case hab.h.a
A : Set ℕ
inst✝¹ : DecidablePred fun x => x ∈ A
B : Set ℕ
inst✝ : DecidablePred fun x => x ∈ B
h : A ⊆ B
x✝ : { n // 0 < n }
⊢ filter (fun x => x ∈ A) (Ioc 0 ↑x✝) ⊆ filter (fun x => x ∈ B) (Ioc 0 ↑x✝)
state_after: no goals
Theorem: MeasureTheory.measure_mul_setLaverage
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: have := Fact.mk h.lt_top
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g f : α → ℝ≥0∞
h : μ s ≠ ⊤
⊢ μ s * ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, f x ∂μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g f : α → ℝ≥0∞
h : μ s ≠ ⊤
this : Fact (μ s < ⊤)
⊢ μ s * ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, f x ∂μ

tactic: rw [← measure_mul_laverage, restrict_apply_univ]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g f : α → ℝ≥0∞
h : μ s ≠ ⊤
this : Fact (μ s < ⊤)
⊢ μ s * ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, f x ∂μ
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.range_comp_subset_range
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [coe_range, coe_comp, Set.range_comp_subset_range]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : β →ₛ γ
g : α → β
hgm : Measurable g
⊢ ↑(f.comp g hgm).range ⊆ ↑f.range
state_after: no goals
Theorem: MeasureTheory.Measure.withDensity_rnDeriv_le
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases hl : HaveLebesgueDecomposition μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : ¬μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ

tactic: conv_rhs => rw [haveLebesgueDecomposition_add μ ν]
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)

tactic: exact Measure.le_add_left le_rfl
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
state_after: no goals

tactic: rw [rnDeriv, dif_neg hl, withDensity_zero]
state_before: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : ¬μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) ≤ μ
state_after: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : ¬μ.HaveLebesgueDecomposition ν
⊢ 0 ≤ μ

tactic: exact Measure.zero_le μ
state_before: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : ¬μ.HaveLebesgueDecomposition ν
⊢ 0 ≤ μ
state_after: no goals
Theorem: Ioo_subset_closure_interior
File: Mathlib/Topology/Order/OrderClosed.lean

tactic: simp only [interior_Ioo, subset_closure]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
a b : α
⊢ Ioo a b ⊆ closure (interior (Ioo a b))
state_after: no goals
Theorem: Finset.pi_nonempty
File: Mathlib/Data/Finset/Pi.lean

tactic: simp [Finset.Nonempty, Classical.skolem]
state_before: α : Type u_1
β : α → Type u
δ : α → Sort v
inst✝ : DecidableEq α
s : Finset α
t : (a : α) → Finset (β a)
⊢ (s.pi t).Nonempty ↔ ∀ a ∈ s, (t a).Nonempty
state_after: no goals
Theorem: isFiniteMeasure_iff_isFiniteMeasureOnCompacts_of_compactSpace
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: constructor <;> intros
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
⊢ IsFiniteMeasure μ ↔ IsFiniteMeasureOnCompacts μ
state_after: case mp
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
a✝ : IsFiniteMeasure μ
⊢ IsFiniteMeasureOnCompacts μ

case mpr
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
a✝ : IsFiniteMeasureOnCompacts μ
⊢ IsFiniteMeasure μ

tactic: infer_instance
state_before: case mp
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
a✝ : IsFiniteMeasure μ
⊢ IsFiniteMeasureOnCompacts μ
state_after: no goals

tactic: exact CompactSpace.isFiniteMeasure
state_before: case mpr
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
a✝ : IsFiniteMeasureOnCompacts μ
⊢ IsFiniteMeasure μ
state_after: no goals
Theorem: Metric.iUnion_inter_closedBall_nat
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [← inter_iUnion, iUnion_closedBall_nat, inter_univ]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝ y z : α
δ ε ε₁ ε₂ : ℝ
s✝ s : Set α
x : α
⊢ ⋃ n, s ∩ closedBall x ↑n = s
state_after: no goals
Theorem: Nat.decreasingInduction_trans
File: Mathlib/Data/Nat/Defs.lean

tactic: induction hnk with
| refl => rw [decreasingInduction_self]
| step hnk ih =>
    rw [decreasingInduction_succ h (Nat.le_trans hmn hnk), ih, decreasingInduction_succ]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
hmn : m ≤ n
hnk : n ≤ k
hP : P k
⊢ decreasingInduction h ⋯ hP = decreasingInduction h hmn (decreasingInduction h hnk hP)
state_after: no goals

tactic: rw [decreasingInduction_self]
state_before: case refl
a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
hmn : m ≤ n
hP : P n
⊢ decreasingInduction h ⋯ hP = decreasingInduction h hmn (decreasingInduction h ⋯ hP)
state_after: no goals

tactic: rw [decreasingInduction_succ h (Nat.le_trans hmn hnk), ih, decreasingInduction_succ]
state_before: case step
a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
hmn : m ≤ n
m✝ : ℕ
hnk : n.le m✝
ih : ∀ (hP : P m✝), decreasingInduction h ⋯ hP = decreasingInduction h hmn (decreasingInduction h hnk hP)
hP : P m✝.succ
⊢ decreasingInduction h ⋯ hP = decreasingInduction h hmn (decreasingInduction h ⋯ hP)
state_after: no goals
Theorem: Turing.ListBlank.cons_bind
File: Mathlib/Computability/TuringMachine.lean

tactic: refine l.inductionOn fun l ↦ ?_
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
⊢ (cons a l).bind f hf = append (f a) (l.bind f hf)
state_after: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
⊢ (cons a ⟦l⟧).bind f hf = append (f a) (bind ⟦l⟧ f hf)

tactic: suffices ((mk l).cons a).bind f hf = ((mk l).bind f hf).append (f a) by exact this
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
⊢ (cons a ⟦l⟧).bind f hf = append (f a) (bind ⟦l⟧ f hf)
state_after: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
⊢ (cons a (mk l)).bind f hf = append (f a) ((mk l).bind f hf)

tactic: simp only [ListBlank.append_mk, ListBlank.bind_mk, ListBlank.cons_mk, List.cons_bind]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
⊢ (cons a (mk l)).bind f hf = append (f a) ((mk l).bind f hf)
state_after: no goals

tactic: exact this
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
this : (cons a (mk l)).bind f hf = append (f a) ((mk l).bind f hf)
⊢ (cons a ⟦l⟧).bind f hf = append (f a) (bind ⟦l⟧ f hf)
state_after: no goals
Theorem: CategoryTheory.Limits.limit.coneMorphism_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
c : Cone F
j : J
⊢ (coneMorphism c).hom ≫ π F j = c.π.app j
state_after: no goals
Theorem: SmoothBumpCovering.embeddingPiTangent_ker_mfderiv
File: Mathlib/Geometry/Manifold/WhitneyEmbedding.lean

tactic: apply bot_unique
state_before: ι : Type uι
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
inst✝ : T2Space M
hi : Fintype ι
s : Set M
f : SmoothBumpCovering ι I M s
x : M
hx : x ∈ s
⊢ LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) = ⊥
state_after: case h
ι : Type uι
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
inst✝ : T2Space M
hi : Fintype ι
s : Set M
f : SmoothBumpCovering ι I M s
x : M
hx : x ∈ s
⊢ LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) ≤ ⊥

tactic: rw [← (mdifferentiable_chart I (f.c (f.ind x hx))).ker_mfderiv_eq_bot
    (f.mem_chartAt_ind_source x hx),
  ← comp_embeddingPiTangent_mfderiv]
state_before: case h
ι : Type uι
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
inst✝ : T2Space M
hi : Fintype ι
s : Set M
f : SmoothBumpCovering ι I M s
x : M
hx : x ∈ s
⊢ LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) ≤ ⊥
state_after: case h
ι : Type uι
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
inst✝ : T2Space M
hi : Fintype ι
s : Set M
f : SmoothBumpCovering ι I M s
x : M
hx : x ∈ s
⊢ LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) ≤
    LinearMap.ker
      (((ContinuousLinearMap.fst ℝ E ℝ).comp (ContinuousLinearMap.proj (f.ind x hx))).comp
        (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x))

tactic: exact LinearMap.ker_le_ker_comp _ _
state_before: case h
ι : Type uι
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
H : Type uH
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝³ : TopologicalSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
inst✝ : T2Space M
hi : Fintype ι
s : Set M
f : SmoothBumpCovering ι I M s
x : M
hx : x ∈ s
⊢ LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) ≤
    LinearMap.ker
      (((ContinuousLinearMap.fst ℝ E ℝ).comp (ContinuousLinearMap.proj (f.ind x hx))).comp
        (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x))
state_after: no goals
Theorem: AlgHom.fst_prod
File: Mathlib/Algebra/Algebra/Prod.lean

tactic: ext
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
⊢ (fst R B C).comp (f.prod g) = f
state_after: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ((fst R B C).comp (f.prod g)) x✝ = f x✝

tactic: rfl
state_before: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ((fst R B C).comp (f.prod g)) x✝ = f x✝
state_after: no goals
Theorem: Real.range_exp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rw [← coe_comp_expOrderIso, range_comp, expOrderIso.range_eq, image_univ, Subtype.range_coe]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
⊢ Set.range rexp = Set.Ioi 0
state_after: no goals
Theorem: List.permutationsAux2_append
File: Mathlib/Data/List/Permutation.lean

tactic: induction ys generalizing f <;> simp [*]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
ys : List α
f : List α → β
⊢ (permutationsAux2 t ts [] ys f).2 ++ r = (permutationsAux2 t ts r ys f).2
state_after: no goals
Theorem: Finset.sup_sup
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction s using Finset.cons_induction with
| empty => rw [sup_empty, sup_empty, sup_empty, bot_sup_eq]
| cons _ _ _ ih =>
  rw [sup_cons, sup_cons, sup_cons, ih]
  exact sup_sup_sup_comm _ _ _ _
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ s.sup (f ⊔ g) = s.sup f ⊔ s.sup g
state_after: no goals

tactic: rw [sup_empty, sup_empty, sup_empty, bot_sup_eq]
state_before: case empty
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ ∅.sup (f ⊔ g) = ∅.sup f ⊔ ∅.sup g
state_after: no goals

tactic: rw [sup_cons, sup_cons, sup_cons, ih]
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
ih : s✝.sup (f ⊔ g) = s✝.sup f ⊔ s✝.sup g
⊢ (cons a✝ s✝ h✝).sup (f ⊔ g) = (cons a✝ s✝ h✝).sup f ⊔ (cons a✝ s✝ h✝).sup g
state_after: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
ih : s✝.sup (f ⊔ g) = s✝.sup f ⊔ s✝.sup g
⊢ (f ⊔ g) a✝ ⊔ (s✝.sup f ⊔ s✝.sup g) = f a✝ ⊔ s✝.sup f ⊔ (g a✝ ⊔ s✝.sup g)

tactic: exact sup_sup_sup_comm _ _ _ _
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
ih : s✝.sup (f ⊔ g) = s✝.sup f ⊔ s✝.sup g
⊢ (f ⊔ g) a✝ ⊔ (s✝.sup f ⊔ s✝.sup g) = f a✝ ⊔ s✝.sup f ⊔ (g a✝ ⊔ s✝.sup g)
state_after: no goals
Theorem: Quaternion.mul_imI
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [one_mul, neg_mul, sub_eq_add_neg, neg_neg]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ a.re * b.imI + a.imI * b.re - -1 * a.imJ * b.imK + -1 * a.imK * b.imJ =
    a.re * b.imI + a.imI * b.re + a.imJ * b.imK - a.imK * b.imJ
state_after: no goals
Theorem: LinearMap.toMatrix_algebraMap
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp [Module.algebraMap_end_eq_smul_id, LinearMap.toMatrix_id, smul_eq_diagonal_mul]
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁶ : Fintype n
inst✝⁵ : Finite m
inst✝⁴ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
x : R
⊢ (toMatrix v₁ v₁) ((algebraMap R (Module.End R M₁)) x) = (scalar n) x
state_after: no goals